聊天程序

最新推荐文章于 2021-01-08 15:01:50 发布
最新推荐文章于 2021-01-08 15:01:50 发布
阅读量366 收藏 1
点赞数
分类专栏： Java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AmerVin/article/details/79517772
版权

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

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();

                         }

                  }

           }

    }

}


AmerVin
关注
专栏目录
Java Socket实现多人聊天室---swing做UI
lianxiangbus
08-31 2417
今天翻硬盘的workspace发现一个Java Socket实现多人聊天室的源码，不记得是什么时候的事情了，貌似不是我写的。但写得还不错， 至少算个有模有样的聊天室工具。我简单的修改了一下，拿出来跟大家分享一下，仅供参考。。。 界面是用swing写的，还不懒，简约大方。有图有真相： 正如上图所示，这个程序分为 服务器端和客户端，说白了就是 两个main ...
基于JAVA-SOCKET的简易聊天器
白驹过隙
06-17 2282
经过对JAVA  , socket的学习
textarea是可以设置字体颜色的
catten的专栏
03-30 1万+
引自：http://www.coderanch.com/t/436752/GUI/java/change-textArea-font-color   Hi, How can I do dynamically change of font color in textArea ? For example: For the first line I will use bl
用户自定义消息SendMessage的使用
Guo_guo
06-20 5584
跟大家分享一下学习MFC的经验。关于MFC的每篇帖子我都会奉上原文档下载地址(百度文库)和源代码的下载地址(CSDN)，都是免金币或积分的！目的就是更加有利于与大家交流，共同进步！因为是初学，所以肯定有疏漏之处，请大家指正。     原文档地址：http://wenku.baidu.com/view/d10b41b8c77da26925c5b0d6.html     源代码地址：htt
局域网聊天小程序
Encounter041的博客
01-08 201
学生管理系统 源码 package com; import java.awt.BorderLayout; import java.awt.Color; import java.awt.GridLayout; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.e
实验一 基于DES加密的TCP聊天程序1
08-03
在本文中，我们将深入探讨基于DES加密的TCP聊天程序的实现，以及DES算法和TCP协议的相关知识。DES（Data Encryption Standard）是一种广泛应用的对称加密算法，它的历史可以追溯到20世纪70年代，由IBM的Lucifer算法...
C++多线程网络聊天程序 .zip
07-12
本项目"**C++多线程网络聊天程序**"旨在演示如何在C++中构建一个能够利用多线程进行实时通信的聊天应用程序。 首先，我们需要了解多线程的基本概念。在单线程程序中，任务是顺序执行的，而在多线程程序中，多个线程...
基于TCP协议网上聊天程序
12-01
本次计算机网络课程设计是基于TCP协议网上聊天程序，程序中用到了套接字socket、多线程thread和Python自带的图形界面库Tkinter，在密码保存和传递方面用到了MD5算法，该程序的功能：用户注册、用户登录、显示在线...
基于C#聊天程序
08-07
【基于C#聊天程序】 C#是一种面向对象的编程语言，由微软公司开发，主要用于构建Windows应用程序、Web应用以及游戏。在开发聊天程序时，C#的强大功能和灵活性使其成为了一个理想的选择。本项目利用C#的核心特性，...
Java版仿QQ聊天程序源码
11-06
【Java版仿QQ聊天程序源码】是一款基于Java编程语言实现的聊天软件，它模仿了QQ的基本功能，为用户提供了一种模拟即时通讯的体验。这个项目涵盖了客户端（MyQQClient）和服务器端两大部分，旨在让学生或者开发者了解...
用java编写一个简单的聊天室，实现私聊和多人聊天，做成图形用户界面的形式
weixin_42394040的博客
03-14 1万+
部分代码如下： package client; import java.awt.BorderLayout; import java.awt.FlowLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt....
Java实现基于Socket的聊天室（三）服务器端
Jiang216的博客
08-18 642
服务器端部分搭建思路及实现 在阅读本篇之前，建议先阅读本篇的前两个部分： Java实现基于Socket的聊天室（一）序言：https://blog.csdn.net/Jiang216/article/details/108070585 Java实现基于Socket的聊天室（二）客户端：https://blog.csdn.net/Jiang216/article/details/108071422 1.1 构建服务器端图形化界面 首先构建服务器端部分的图形化显示界面，构建ChatServerView
java网络编程
xumajie88的专栏
02-18 910
现在是个网络信息爆炸的时代，所以学会网络编程很有必要，比如说网站的内容推送和与在线用户的聊天等等 一、TCP协议编程（可靠连接） 使用serversocket和socket实现服务器和客户端的通信，步骤如下 1、建立连接 2、获取输入/输出流的数据 3、读/写数据 4、关闭流 5、关闭socket 二、UDP编程(不可靠连接)
窗口SendMessage参数详解
积微成著
07-28 3481
WM_ Window Message 窗口消息，一般用在SendMessage，PostMessage这样的消息函数中 SM_ Static Message 静态标签消息 SS_ Static Style 静态标签风格 BM_ Button Message 按钮消息 BS_ Button Style 按钮风格 BN_ Button Notify 按钮通知 EM_ Edit Message 编辑框消息
Java实战_局域网多人聊天室
chance2015的博客
01-03 1万+
由于需要制作网络计算机网络课程设计，并且不想搞网络布线或者局域网路由器配置等等这种完全搞不懂的东西，最后决定使用socket基于java编写一个局域网聊天室： 关于socket以及网络编程的相关知识详见我另一篇文章:Java基于socket编程 程序基于C/S结构，即客户端服务器模式。 服务器： 默认ip为本机ip 需要双方确定一个端口号 可设置最大连接人数 可启动与关闭 界面显示在
Java聊天室
Windsearcher的博客
11-27 324
1.首先是服务器的界面实现，如下：       2.如何实现呢？主要使用swing和awt，首先整个是一个Frame容器，然后设定它的布局为BoderLayout,最上边的是一个Panel,设定它的布局为GridLayout,中间使用了JSplitPane，把左右两个面板放在里面 、  最下边也是一个面板，里面套了写组件 package com.example.li; impo...
Java编程：Socket聊天室
杀丶破狼
06-10 858
服务器端 //服务器端 package doudou; import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.border.*; import java.io.*; import java.net.BindException; import java.net.ServerSoc
Java写的简单Socket聊天室
doudou15223155621的专栏
03-21 1万+
//服务器端package doudou;import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.border.*;import java.io.*;import java.net.BindException;import java.net.Serve
SetWindowText函数（详解）
热门推荐
会飞的丑小鸭的博客
05-14 3万+
SetWindowText函数 设置对话框标题或者对话框控件文本的内容例子 作用 向对话框中的控件发送消息 和SetWindowText作用一样 例子 获取对话框中控件的句柄 例子: INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {     UNREFERENCED
JAVA实现简单聊天程序
"JAVA 简单聊天程序" 这是一个基于Java实现的简单聊天程序，它包含两个主要部分：服务器端（Server）和客户端（Client）。在这个程序中，我们看到服务器端使用了`ServerSocket`类来创建一个监听特定端口（6666）的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值