聊天程序

分为服务器端和客户端分别实现。

1、  客户端

              messageThread = importjava.awt.BorderLayout;

importjava.awt.Color;

importjava.awt.GridLayout;

importjava.awt.Toolkit;

importjava.awt.event.ActionEvent;

importjava.awt.event.ActionListener;

importjava.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

importjava.io.PrintWriter;

importjava.net.Socket;

importjava.util.HashMap;

importjava.util.Map;

importjava.util.StringTokenizer;

 

importjavax.swing.DefaultListModel;

importjavax.swing.JButton;

importjavax.swing.JFrame;

importjavax.swing.JLabel;

importjavax.swing.JList;

importjavax.swing.JOptionPane;

importjavax.swing.JPanel;

importjavax.swing.JScrollPane;

import javax.swing.JSplitPane;

importjavax.swing.JTextArea;

importjavax.swing.JTextField;

importjavax.swing.border.TitledBorder;

 

public classClient{

 

    private JFrame frame;

    private JList userList;

    private JTextArea textArea;

    private JTextField textField;

    private JTextField txt_port;

    private JTextField txt_hostIp;

    private JTextField txt_name;

    private JButton btn_start;

    private JButton btn_stop;

    private JButton btn_send;

    private JPanel northPanel;

    private JPanel southPanel;

    private JScrollPane rightScroll;

    private JScrollPane leftScroll;

    private JSplitPane centerSplit;

 

    private DefaultListModel listModel;

    private boolean isConnected = false;

 

    private Socket socket;

    private PrintWriter writer;

    private BufferedReader reader;

    private MessageThread messageThread;// 负责接收消息的线程

    private Map<String, User> onLineUsers= new HashMap<String, User>();// 所有在线用户

 

    // 主方法,程序入口

    public static void main(String[] args) {

           new Client();

    }

 

    // 执行发送

    public void send() {

           if (!isConnected) {

                  JOptionPane.showMessageDialog(frame,"还没有连接服务器,无法发送消息!", "错误",

                                JOptionPane.ERROR_MESSAGE);

                  return;

           }

           String message =textField.getText().trim();

           if (message == null ||message.equals("")) {

                  JOptionPane.showMessageDialog(frame,"消息不能为空!", "错误",

                                JOptionPane.ERROR_MESSAGE);

                  return;

           }

           sendMessage(frame.getTitle() +"@" + "ALL" + "@" + message);

           textField.setText(null);

    }

 

    // 构造方法

    public Client() {

           textArea = new JTextArea();

           textArea.setEditable(false);

           textArea.setForeground(Color.blue);

           textField = new JTextField();

           txt_port = newJTextField("");                 //设置端口号和

           txt_hostIp = newJTextField("127.0.0.1");

           txt_name = newJTextField("");

           btn_start = new JButton("连接");

           btn_stop = new JButton("断开");

           btn_send = new JButton("发送");

           listModel = new DefaultListModel();

           userList = new JList(listModel);

 

           northPanel = new JPanel();

           northPanel.setLayout(newGridLayout(1, 7));

           northPanel.add(new JLabel("端口"));

           northPanel.add(txt_port);

           northPanel.add(new JLabel("服务器IP"));

           northPanel.add(txt_hostIp);

           northPanel.add(new JLabel("昵称"));

           northPanel.add(txt_name);

           northPanel.add(btn_start);

           northPanel.add(btn_stop);

           northPanel.setBorder(newTitledBorder("连接信息显示区"));

 

           rightScroll = newJScrollPane(textArea);

           rightScroll.setBorder(newTitledBorder("消息显示区"));

           leftScroll = newJScrollPane(userList);

           leftScroll.setBorder(newTitledBorder("在线用户显示区"));

           southPanel = new JPanel(newBorderLayout());

           southPanel.add(textField,"Center");

           southPanel.add(btn_send,"East");

           southPanel.setBorder(newTitledBorder("输入消息"));

 

           centerSplit = newJSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScroll,

                         rightScroll);

           centerSplit.setDividerLocation(100);

 

           frame = new JFrame("客户端界面");

           // 更改JFrame的图标:

// frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));

           frame.setLayout(new BorderLayout());

           frame.add(northPanel,"North");

           frame.add(centerSplit,"Center");

           frame.add(southPanel,"South");

           frame.setSize(600, 400);

           int screen_width =Toolkit.getDefaultToolkit().getScreenSize().width;

           int screen_height =Toolkit.getDefaultToolkit().getScreenSize().height;

           frame.setLocation((screen_width -frame.getWidth()) / 2,

                         (screen_height -frame.getHeight()) / 2);

           frame.setVisible(true);

 

           // 写消息的文本框中按回车键时事件

           textField.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent arg0) {

                         send();

                  }

           });

 

           // 单击发送按钮时事件

           btn_send.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         send();

                  }

           });

 

           // 单击连接按钮时事件

           btn_start.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         int port;

                         if (isConnected) {

                                JOptionPane.showMessageDialog(frame,"已处于连接上状态,不要重复连接!",

                                              "错误", JOptionPane.ERROR_MESSAGE);

                                return;

                         }

                         try {

                                try {

                                       port =Integer.parseInt(txt_port.getText().trim());

                                } catch(NumberFormatException e2) {

                                       throw newException("端口号不符合要求!端口为整数!");

                                }

                                String hostIp =txt_hostIp.getText().trim();

                                String name =txt_name.getText().trim();

                                if(name.equals("") || hostIp.equals("")) {

                                       throw newException("姓名、服务器IP不能为空!");

                                }

                                booleanflag = connectServer(port, hostIp, name);

                                if (flag ==false) {

                                       throw newException("与服务器连接失败!");

                                }

                                frame.setTitle(name);

                                JOptionPane.showMessageDialog(frame,"成功连接!");

                         } catch (Exception exc){

                                JOptionPane.showMessageDialog(frame,exc.getMessage(),

                                              "错误", JOptionPane.ERROR_MESSAGE);

                         }

                  }

           });

 

           // 单击断开按钮时事件

           btn_stop.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         if (!isConnected) {

                                JOptionPane.showMessageDialog(frame, "已处于断开状态,不要重复断开!",

                                              "错误", JOptionPane.ERROR_MESSAGE);

                                return;

                         }

                         try {

                                boolean flag =closeConnection();// 断开连接

                                if (flag ==false) {

                                       throw newException("断开连接发生异常!");

                                }

                                JOptionPane.showMessageDialog(frame,"成功断开!");

                         } catch (Exception exc){

                                JOptionPane.showMessageDialog(frame,exc.getMessage(),

                                              "错误", JOptionPane.ERROR_MESSAGE);

                         }

                  }

           });

 

           // 关闭窗口时事件

           frame.addWindowListener(newWindowAdapter() {

                  public voidwindowClosing(WindowEvent e) {

                         if (isConnected) {

                                closeConnection();//关闭连接

                         }

                         System.exit(0);// 退出程序

                  }

           });

    }

 

    /**

     * 连接服务器

     *

     *@param port

     *@param hostIp

     *@param name

     */

    public boolean connectServer(int port,String hostIp, String name) {

           // 连接服务器

           try {

                  socket = new Socket(hostIp,port);// 根据端口号和服务器ip建立连接

                  writer = newPrintWriter(socket.getOutputStream());

                  reader = newBufferedReader(new InputStreamReader(socket

                                .getInputStream()));

                  // 发送客户端用户基本信息(用户名和ip地址)

                  sendMessage(name +"@" + socket.getLocalAddress().toString());

                  // 开启接收消息的线程

newMessageThread(reader, textArea);

                  messageThread.start();

                  isConnected = true;// 已经连接上了

                  return true;

           } catch (Exception e) {

                  textArea.append("与端口号为:" + port + "    IP地址为:" + hostIp

                                + "   的服务器连接失败!" +"\r\n");

                  isConnected = false;// 未连接上

                  return false;

           }

    }

 

    /**

     * 发送消息

     *

     *@param message

     */

    public void sendMessage(String message) {

           writer.println(message);

           writer.flush();

    }

 

    /**

     * 客户端主动关闭连接

     */

    @SuppressWarnings("deprecation")

    public synchronized booleancloseConnection() {

           try {

                  sendMessage("CLOSE");//发送断开连接命令给服务器

                  messageThread.stop();// 停止接受消息线程

                  // 释放资源

                  if (reader != null) {

                         reader.close();

                  }

                  if (writer != null) {

                         writer.close();

                  }

                  if (socket != null) {

                         socket.close();

                  }

                  isConnected = false;

                  return true;

           } catch (IOException e1) {

                  e1.printStackTrace();

                  isConnected = true;

                  return false;

           }

    }

 

    // 不断接收消息的线程

    class MessageThread extends Thread {

           private BufferedReader reader;

           private JTextArea textArea;

 

           // 接收消息线程的构造方法

           public MessageThread(BufferedReaderreader, JTextArea textArea) {

                  this.reader = reader;

                  this.textArea = textArea;

           }

 

           // 被动的关闭连接

           public synchronized void closeCon()throws Exception {

                  // 清空用户列表

                  listModel.removeAllElements();

                  // 被动的关闭连接释放资源

                  if (reader != null) {

                         reader.close();

                  }

                  if (writer != null) {

                         writer.close();

                  }

                  if (socket != null) {

                         socket.close();

                  }

                  isConnected = false;// 修改状态为断开

           }

 

           public void run() {

                  String message = "";

                  while (true) {

                         try {

                                message =reader.readLine();

                                StringTokenizerstringTokenizer = new StringTokenizer(

                                              message,"/@");

                                String command =stringTokenizer.nextToken();// 命令

                                if(command.equals("CLOSE"))// 服务器已关闭命令

                                {

                                       textArea.append("服务器已关闭!\r\n");

                                       closeCon();//被动的关闭连接

                                       return;//结束线程

                                } else if(command.equals("ADD")) {// 有用户上线更新在线列表

                                       Stringusername = "";

                                       StringuserIp = "";

                                       if((username = stringTokenizer.nextToken()) != null

                                                     &&(userIp = stringTokenizer.nextToken()) != null) {

                                              Useruser = new User(username, userIp);

                                              onLineUsers.put(username,user);

                                              listModel.addElement(username);

                                       }

                                } else if(command.equals("DELETE")) {// 有用户下线更新在线列表

                                       Stringusername = stringTokenizer.nextToken();

                                       User user= (User) onLineUsers.get(username);

                                       onLineUsers.remove(user);

                                       listModel.removeElement(username);

                                } else if(command.equals("USERLIST")) {// 加载在线用户列表

                                       int size= Integer

                                                     .parseInt(stringTokenizer.nextToken());

                                       Stringusername = null;

                                       StringuserIp = null;

                                       for (inti = 0; i < size; i++) {

                                              username= stringTokenizer.nextToken();

                                              userIp= stringTokenizer.nextToken();

                                              Useruser = new User(username, userIp);

                                              onLineUsers.put(username,user);

                                              listModel.addElement(username);

                                       }

                                } else if(command.equals("MAX")) {// 人数已达上限

                                       textArea.append(stringTokenizer.nextToken()

                                                     +stringTokenizer.nextToken() + "\r\n");

                                       closeCon();//被动的关闭连接

                                       JOptionPane.showMessageDialog(frame,"服务器缓冲区已满!", "错误",

                                                     JOptionPane.ERROR_MESSAGE);

                                       return;//结束线程

                                } else {// 普通消息

                                       textArea.append(message+ "\r\n");

                                }

                         } catch (IOException e){

                                e.printStackTrace();

                         } catch (Exception e) {

                                e.printStackTrace();

                         }

                  }

           }

    }

}

2、        服务器端

import java.awt.BorderLayout;

importjava.awt.Color;

importjava.awt.GridLayout;

importjava.awt.Toolkit;

importjava.awt.event.ActionEvent;

importjava.awt.event.ActionListener;

importjava.awt.event.WindowAdapter;

importjava.awt.event.WindowEvent;

import java.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

importjava.io.PrintWriter;

importjava.net.BindException;

importjava.net.ServerSocket;

importjava.net.Socket;

importjava.util.ArrayList;

importjava.util.StringTokenizer;

 

importjavax.swing.DefaultListModel;

importjavax.swing.JButton;

importjavax.swing.JFrame;

importjavax.swing.JLabel;

importjavax.swing.JList;

importjavax.swing.JOptionPane;

importjavax.swing.JPanel;

importjavax.swing.JScrollPane;

importjavax.swing.JSplitPane;

importjavax.swing.JTextArea;

importjavax.swing.JTextField;

importjavax.swing.border.TitledBorder;

 

public classServer {

 

    private JFrame frame;

    private JTextArea contentArea;

    private JTextField txt_message;

    private JTextField txt_max;

    private JTextField txt_port;

    private JButton btn_start;

    private JButton btn_stop;

    private JButton btn_send;

    private JPanel northPanel;

    private JPanel southPanel;

    private JScrollPane rightPanel;

    private JScrollPane leftPanel;

    private JSplitPane centerSplit;

    private JList userList;

    private DefaultListModel listModel;

 

    private ServerSocket serverSocket;

    private ServerThread serverThread;

    private ArrayList<ClientThread>clients;

 

    private boolean isStart = false;

 

    // 主方法,程序执行入口

    public static void main(String[] args) {

           new Server();

    }

 

    // 执行消息发送

    public void send() {

           if (!isStart) {

                  JOptionPane.showMessageDialog(frame,"服务器还未启动,不能发送消息!", "错误",

                                JOptionPane.ERROR_MESSAGE);

                  return;

           }

           if (clients.size() == 0) {

                  JOptionPane.showMessageDialog(frame,"没有用户在线,不能发送消息!", "错误",

                                JOptionPane.ERROR_MESSAGE);

                  return;

           }

           String message =txt_message.getText().trim();

           if (message == null ||message.equals("")) {

                  JOptionPane.showMessageDialog(frame,"消息不能为空!", "错误",

                                JOptionPane.ERROR_MESSAGE);

                  return;

           }

           sendServerMessage(message);// 群发服务器消息

           contentArea.append("服务器说:" + txt_message.getText() + "\r\n");

           txt_message.setText(null);

    }

 

    // 构造方法

    public Server() {

           frame = new JFrame("服务器端界面");

           // 更改JFrame的图标:

    //frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));

// frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Server.class.getResource("qq.png")));

           contentArea = new JTextArea();

           contentArea.setEditable(false);

           contentArea.setForeground(Color.blue);

           txt_message = new JTextField();

           txt_max = newJTextField("30");

           txt_port = newJTextField("6666");

           btn_start = new JButton("启动");

           btn_stop = new JButton("停止");

           btn_send = new JButton("发送");

           btn_stop.setEnabled(false);

           listModel = new DefaultListModel();

           userList = new JList(listModel);

 

           southPanel = new JPanel(newBorderLayout());

           southPanel.setBorder(newTitledBorder("输入消息"));

           southPanel.add(txt_message,"Center");

           southPanel.add(btn_send,"East");

           leftPanel = newJScrollPane(userList);

           leftPanel.setBorder(newTitledBorder("在线用户"));

 

           rightPanel = newJScrollPane(contentArea);

           rightPanel.setBorder(newTitledBorder("消息显示区"));

 

           centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,leftPanel,

                         rightPanel);

           centerSplit.setDividerLocation(100);

           northPanel = new JPanel();

           northPanel.setLayout(newGridLayout(1, 6));

           northPanel.add(new JLabel("人数上限"));

           northPanel.add(txt_max);

           northPanel.add(new JLabel("端口"));

           northPanel.add(txt_port);

           northPanel.add(btn_start);

           northPanel.add(btn_stop);

           northPanel.setBorder(newTitledBorder("配置信息"));

 

           frame.setLayout(new BorderLayout());

           frame.add(northPanel,"North");

           frame.add(centerSplit,"Center");

           frame.add(southPanel,"South");

           frame.setSize(600, 400);

           //frame.setSize(Toolkit.getDefaultToolkit().getScreenSize());//设置全屏

           int screen_width =Toolkit.getDefaultToolkit().getScreenSize().width;

           int screen_height =Toolkit.getDefaultToolkit().getScreenSize().height;

           frame.setLocation((screen_width -frame.getWidth()) / 2,

                         (screen_height -frame.getHeight()) / 2);

           frame.setVisible(true);

 

           // 关闭窗口时事件

           frame.addWindowListener(newWindowAdapter() {

                  public voidwindowClosing(WindowEvent e) {

                         if (isStart) {

                                closeServer();//关闭服务器

                         }

                         System.exit(0);// 退出程序

                  }

           });

 

           // 文本框按回车键时事件

           txt_message.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         send();

                  }

           });

 

           // 单击发送按钮时事件

           btn_send.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent arg0) {

                         send();

                  }

           });

 

           // 单击启动服务器按钮时事件

           btn_start.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         if (isStart) {

                                JOptionPane.showMessageDialog(frame,"服务器已处于启动状态,不要重复启动!",

                                              "错误", JOptionPane.ERROR_MESSAGE);

                                return;

                         }

                         int max;

                         int port;

                         try {

                                try {

                                       max =Integer.parseInt(txt_max.getText());

                                } catch(Exception e1) {

                                       throw newException("人数上限为正整数!");

                                }

                                if (max <= 0){

                                       throw newException("人数上限为正整数!");

                                }

                                try {

                                       port =Integer.parseInt(txt_port.getText());

                                } catch(Exception e1) {

                                       throw newException("端口号为正整数!");

                                }

                                if (port <=0) {

                                       throw newException("端口号为正整数!");

                                }

                                serverStart(max,port);

                                contentArea.append("服务器已成功启动!人数上限:" + max + ",端口:" + port

                                              +"\r\n");

                                JOptionPane.showMessageDialog(frame,"服务器成功启动!");

                                btn_start.setEnabled(false);

                                txt_max.setEnabled(false);

                                txt_port.setEnabled(false);

                                btn_stop.setEnabled(true);

                         } catch (Exception exc){

                                JOptionPane.showMessageDialog(frame,exc.getMessage(),

                                              "错误", JOptionPane.ERROR_MESSAGE);

                         }

                  }

           });

 

           // 单击停止服务器按钮时事件

           btn_stop.addActionListener(newActionListener() {

                  public voidactionPerformed(ActionEvent e) {

                         if (!isStart) {

                                JOptionPane.showMessageDialog(frame,"服务器还未启动,无需停止!", "错误",

                                              JOptionPane.ERROR_MESSAGE);

                                return;

                         }

                         try {

                                closeServer();

                                btn_start.setEnabled(true);

                                txt_max.setEnabled(true);

                                txt_port.setEnabled(true);

                                btn_stop.setEnabled(false);

                                contentArea.append("服务器成功停止!\r\n");

                                JOptionPane.showMessageDialog(frame,"服务器成功停止!");

                         } catch (Exception exc){

                                JOptionPane.showMessageDialog(frame,"停止服务器发生异常!", "错误",

                                              JOptionPane.ERROR_MESSAGE);

                         }

                  }

           });

    }

 

    // 启动服务器

    public void serverStart(int max, int port)throws java.net.BindException {

           try{

                  clients = newArrayList<ClientThread>();

                  serverSocket = newServerSocket(port);

                  serverThread = newServerThread(serverSocket, max);

                  serverThread.start();

                  isStart = true;

           } catch (BindException e) {

                  isStart = false;

                  throw new BindException("端口号已被占用,请换一个!");

           } catch (Exception e1) {

                  e1.printStackTrace();

                  isStart = false;

                  throw new BindException("启动服务器异常!");

           }

    }

 

    // 关闭服务器

    @SuppressWarnings("deprecation")

    public void closeServer() {

           try {

                  if (serverThread != null)

                         serverThread.stop();// 停止服务器线程

 

                  for (int i = clients.size() -1; i >= 0; i--) {

                         // 给所有在线用户发送关闭命令

                         clients.get(i).getWriter().println("CLOSE");

                         clients.get(i).getWriter().flush();

                         // 释放资源

                         clients.get(i).stop();//停止此条为客户端服务的线程

                         clients.get(i).reader.close();

                         clients.get(i).writer.close();

                         clients.get(i).socket.close();

                         clients.remove(i);

                  }

                  if (serverSocket != null) {

                         serverSocket.close();//关闭服务器端连接

                  }

                  listModel.removeAllElements();//清空用户列表

                  isStart= false;

           } catch (IOException e) {

                  e.printStackTrace();

                  isStart = true;

           }

    }

 

    // 群发服务器消息

    public void sendServerMessage(Stringmessage) {

           for (int i = clients.size() - 1; i>= 0; i--) {

                  clients.get(i).getWriter().println("服务器:" + message + "(多人发送)");

                  clients.get(i).getWriter().flush();

           }

    }

 

    // 服务器线程

    class ServerThread extends Thread {

           private ServerSocket serverSocket;

           private int max;// 人数上限

 

           // 服务器线程的构造方法

           public ServerThread(ServerSocketserverSocket, int max) {

                  this.serverSocket =serverSocket;

                  this.max = max;

           }

 

           public void run() {

                  while (true) {// 不停的等待客户端的链接

                         try {

                                Socket socket =serverSocket.accept();

                                if(clients.size() == max) {// 如果已达人数上限

                                       BufferedReaderr = new BufferedReader(

                                                     newInputStreamReader(socket.getInputStream()));

                                       PrintWriterw = new PrintWriter(socket

                                                     .getOutputStream());

                                       // 接收客户端的基本用户信息

                                       Stringinf = r.readLine();

                                       StringTokenizerst = new StringTokenizer(inf, "@");

                                       User user= new User(st.nextToken(), st.nextToken());

                                       // 反馈连接成功信息

                                       w.println("MAX@服务器:对不起," + user.getName()

                                                     +user.getIp() + ",服务器在线人数已达上限,请稍后尝试连接!");

                                       w.flush();

                                       // 释放资源

                                       r.close();

                                       w.close();

                                       socket.close();

                                       continue;

                                }

                                ClientThreadclient = new ClientThread(socket);

                                client.start();//开启对此客户端服务的线程

                                clients.add(client);

                                listModel.addElement(client.getUser().getName());//更新在线列表

                                contentArea.append(client.getUser().getName()

                                              +client.getUser().getIp() + "上线!\r\n");

                         } catch (IOException e){

                                e.printStackTrace();

                         }

                  }

           }

    }

 

    // 为一个客户端服务的线程

    class ClientThread extends Thread {

           private Socket socket;

           private BufferedReader reader;

           private PrintWriter writer;

           private User user;

 

           public BufferedReader getReader() {

                  return reader;

           }

 

           public PrintWriter getWriter() {

                  return writer;

           }

 

           public User getUser() {

                  return user;

           }

 

           // 客户端线程的构造方法

           public ClientThread(Socket socket) {

                  try {

                         this.socket = socket;

                         reader = newBufferedReader(new InputStreamReader(socket

                                       .getInputStream()));

                         writer = newPrintWriter(socket.getOutputStream());

                         // 接收客户端的基本用户信息

                         String inf =reader.readLine();

                         StringTokenizer st =new StringTokenizer(inf, "@");

                         user = newUser(st.nextToken(), st.nextToken());

                         // 反馈连接成功信息

                         writer.println(user.getName()+ user.getIp() + "与服务器连接成功!");

                         writer.flush();

                         // 反馈当前在线用户信息

                         if (clients.size() >0) {

                                Stringtemp = "";

                                for (int i =clients.size() - 1; i >= 0; i--) {

                                       temp +=(clients.get(i).getUser().getName() + "/" + clients

                                                     .get(i).getUser().getIp())

                                                     +"@";

                                }

                                writer.println("USERLIST@"+ clients.size() + "@" + temp);

                                writer.flush();

                         }

                         // 向所有在线用户发送该用户上线命令

                         for (int i =clients.size() - 1; i >= 0; i--) {

                                clients.get(i).getWriter().println(

                                              "ADD@"+ user.getName() + user.getIp());

                                clients.get(i).getWriter().flush();

                         }

                  } catch (IOException e) {

                         e.printStackTrace();

                  }

           }

 

           @SuppressWarnings("deprecation")

           public void run() {// 不断接收客户端的消息,进行处理。

                  String message = null;

                  while (true) {

                         try {

                                message =reader.readLine();// 接收客户端消息

                                if(message.equals("CLOSE"))// 下线命令

                                {

                                       contentArea.append(this.getUser().getName()

                                                     +this.getUser().getIp() + "下线!\r\n");

                                       // 断开连接释放资源

                                       reader.close();

                                       writer.close();

                                       socket.close();

 

                                       // 向所有在线用户发送该用户的下线命令

                                       for (inti = clients.size() - 1; i >= 0; i--) {

                                              clients.get(i).getWriter().println(

                                                            "DELETE@"+ user.getName());

                                              clients.get(i).getWriter().flush();

                                       }

 

                                       listModel.removeElement(user.getName());//更新在线列表

 

                                       // 删除此条客户端服务线程

                                       for (inti = clients.size() - 1; i >= 0; i--) {

                                              if(clients.get(i).getUser() == user) {

                                                     ClientThreadtemp = clients.get(i);

                                                     clients.remove(i);//删除此用户的服务线程

                                                     temp.stop();//停止这条服务线程

                                                     return;

                                              }

                                       }

                                } else {

                                       dispatcherMessage(message);// 转发消息

                                }

                         } catch (IOException e){

                                e.printStackTrace();

                         }

                  }

           }

           // 转发消息

           public void dispatcherMessage(Stringmessage) {

                  StringTokenizerstringTokenizer = new StringTokenizer(message, "@");

                  String source =stringTokenizer.nextToken();

                  String owner =stringTokenizer.nextToken();

                  String content =stringTokenizer.nextToken();

                  message = source + "说:" + content;

                  contentArea.append(message +"\r\n");

                  if(owner.equals("ALL")) {// 群发

                         for (int i =clients.size() - 1; i >= 0; i--) {

                                clients.get(i).getWriter().println(message+ "(多人发送)");

                                clients.get(i).getWriter().flush();

                         }

                  }

           }

    }

}


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值