Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

基于Socket通信的电商客服系统实现。基本功能要求:用户端:可以发起连接,等待客服端响应,客服端长时间未响应,需要显示客服忙提示;除了可以发送文字外,还可以发送图片;客服端:可…

  1. User

    基于Socket通信的电商客服系统实现。基本功能要求:用户端:可以发起连接,等待客服端响应,客服端长时间未响应,需要显示客服忙提示;除了可以发送文字外,还可以发送图片;客服端:可以同时服务多个用户,有新的用户申请服务时有提示,可以选择服务或者拒绝服务;除了可以发送文字外,还可以发送文件给用户;聊天记录需要保存在本地一个文件,同一个用户再次申请聊天时,需要打开文件,导入聊天记录,可以在聊天框查看之前记录;提示:有文件保存和打开功能,因此会用到文件的读写;有文字、文件、图片传输功能,因此需要进行Socket通信,参;需要设计聊天界面,用swing实现;在设计过程中还需要考虑异常处理和线程问题

  2. Assistant

    。

    设计思路:

    1.客服端与用户端建立Socket连接,通过输入IP地址与端口号进行连接。如果客服端在服务其他用户,则需要显示忙提示,不能与该用户进行连接。

    2.客服端可以同时服务多个用户,每当用户申请服务时,客服端会有提示,选择接受服务或拒绝服务。客服端需要维护一个用户列表,记录当前服务用户。

    3.用户可以发送文字、图片,并且客服端也可以发送文字、文件。所有聊天记录需要保存在本地文件中。

    4.如果是同一个用户再次申请聊天,那么需要打开文件导入聊天记录,显示在聊天框中。

    5.需要设计聊天界面,使用Swing实现。

    6.需要进行异常处理和线程问题。

    设计流程:

    1.创建客服端与用户端的Socket连接。

    2.客服端初始状态为闲,记录当前服务的用户列表。

    3.客服端等待用户请求服务,并进行相应的处理。

    4.用户发送消息,客服端接收消息,并保存在本地文件中。

    5.客服端响应用户消息,并发送消息到用户端。

    6.客服端与用户端的聊天记录保存在本地文件中。

    7.聊天界面使用Swing实现。

    8.异常处理和线程问题。

    代码实现:

    客服端:

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.swing.JFileChooser;
    import javax.swing.JFrame;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    
    public class Server extends JFrame {
    
        private static final long serialVersionUID = -4622357406573952938L;
    
        private List<Socket> socketList = new ArrayList<Socket>();// 维护客户端socket列表
        private List<String> userList = new ArrayList<String>();// 维护当前服务用户列表
        private String busyMsg = "客服忙,请耐心等候。。。";
        private JTextArea textArea;
    
        public Server() {
    
            setTitle("客服端");
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setSize(300, 400);
            setLocationRelativeTo(null);
            setResizable(false);
            textArea = new JTextArea();
            textArea.setEditable(false);
            JScrollPane scrollPane = new JScrollPane();
            scrollPane.setViewportView(textArea);
            getContentPane().add(scrollPane);
    
            setVisible(true);
    
            try {
                ServerSocket serverSocket = new ServerSocket(9000);// 创建服务器端Socket
                textArea.append("服务端创建成功\n");
                while (true) {// 等待客户端请求
                    Socket socket = serverSocket.accept();// 接收客户端连接请求
                    if (socketList.size() >= 5) {// 当客服正在为5个用户服务时,返回忙提示
                        PrintWriter pw = new PrintWriter(socket.getOutputStream());
                        pw.println(busyMsg);
                        pw.flush();
                        socket.close();
                        continue;
                    }
    
                    // 建立连接后启动线程,并加入列表中
                    socketList.add(socket);
                    Thread thread = new Thread(new ServiceThread(socket));
                    textArea.append("客户端连接成功,IP地址为:" + socket.getInetAddress() + ":" + socket.getPort() + "\n");
                    thread.start();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * ServiceThread类,线程类,用于处理客户端请求
         *
         */
        class ServiceThread implements Runnable {
    
            Socket socket;
            BufferedReader br;
            PrintWriter pw;
            String username;
            File recordFile;
    
            public ServiceThread(Socket socket) throws IOException {
                this.socket = socket;
                this.br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
                this.pw = new PrintWriter(this.socket.getOutputStream());
            }
    
            public void run() {
                try {
                    // 第一次建立连接时,客户端需要确认用户名
                    if (!loginConfirm()) {
                        closeSocket();
                        return;
                    }
    
                    while (true) {
                        String msg = br.readLine();// 接收客户端发送的数据
                        if (msg.equals("quit")) {
                            // 如果用户退出,从服务列表中移除用户,关闭socket
                            userList.remove(username);
                            socketList.remove(socket);
                            saveRecord();// 保存聊天记录
                            closeSocket();
                            break;
                        }
                        if (msg.equals("showusers")) {
                            sendUserList();// 向客户端发送当前服务用户列表
                            continue;
                        }
    
                        String[] tokens = msg.split(":");
                        if (tokens.length == 1) {
                            if (msg.equals("files")) {// 客户端传送了文件
                                saveFile();// 接收客户端传送的文件,并保存在磁盘中
                                continue;
                            }
                            printMessage(username + " 发送的消息: " + msg);// 输出消息
                            sendToAll(username + ": " + msg);// 发送消息到所有客户端
                        } else if (tokens.length == 2) {
                            if (tokens[0].equals("login")) {// 用户申请服务
                                if (!addUser(tokens[1])) {// 如果当前已经为5个用户服务,则返回客户端忙提示
                                    String busyMsg = "该客服正在为" + userList.size() + "个用户服务,请耐心等待。。。";
                                    printMessage(username + ": 服务忙");
                                    sendToClient(socket, busyMsg);// 发送忙提示到客户端
                                } else {
                                    printMessage(tokens[1] + " 请求服务");
                                    refreshUserList();// 刷新用户列表
                                    sendUserList();// 发送用户列表信息到所有客户端
                                }
                            } else if (tokens[0].equals("agree")) {// 客服同意为客户提供服务
                                sendToClient(username, "你好," + tokens[1] + ",我是客服,有什么问题吗?");
                            } else if (tokens[0].equals("disagree")) {// 客服拒绝为客户提供服务
                                sendToClient(tokens[1], "客服忙,请耐心等候。。。");
                            }
                        }
                    }
                } catch (IOException e) {
                    closeSocket();
                    e.printStackTrace();
                }
    
            }
    
            /**
             * 显示消息
             */
            private void printMessage(String msg) {
                textArea.append(msg + "\n");
            }
    
            /**
             * 向所有客户端发送消息
             * @param msg
             */
            private void sendToAll(String msg) {
                for (Socket s : socketList) {
                    if (!s.equals(socket)) {
                        sendToClient(s, msg);
                    }
                }
            }
    
            /**
             * 向客户端发送消息
             * @param socket
             * @param msg
             */
            private void sendToClient(Socket socket, String msg) {
                try {
                    PrintWriter pw = new PrintWriter(socket.getOutputStream());
                    pw.println(msg);
                    pw.flush();
                } catch (IOException e) {
                    closeSocket();
                    e.printStackTrace();
                }
            }
    
            private void sendToClient(String username, String msg) {
                for (Socket s : socketList) {
                    ServiceThread st = findServiceThread(s);
                    if (st.username.equals(username)) {
                        sendToClient(s, msg);
                        break;
                    }
                }
            }
    
            /**
             * 判断当前已经为5个用户服务时,客服是否还能提供服务
             * @return
             */
            private boolean canServiceMoreUsers() {
                return socketList.size() < 5;
            }
    
            /**
             * 判断登录是否成功
             * @return
             * @throws IOException
             */
            private boolean loginConfirm() throws IOException {
                String msg = br.readLine();// 接收客户端发送的数据
                while (msg.startsWith("login:")) {
                    username = msg.split(":")[1];
                    if (userList.contains(username)) {
                        // 该用户已经为服务列表中的用户服务了
                        sendToClient(socket, "login:error 用户名 \"" + username + "\" 已经在服务列表中!");
                        msg = br.readLine();
                        continue;
                    }
                    userList.add(username);
                    refreshUserList();// 刷新用户列表
                    saveRecord();// 保存聊天记录,若没有则新建
                    sendUserList();// 发送用户列表信息到所有客户端
                    return true;
                }
                return false;
            }
    
            /**
             * 向所有客户端发送当前服务用户列表
             */
            private void sendUserList() {
                String msg = "showusers:";
                for (String u : userList) {
                    msg += u + ",";
                }
                for (Socket s : socketList) {
                    sendToClient(s, msg);
                }
            }
    
            /**
             * 关闭socket
             */
            private void closeSocket() {
                try {
                    br.close();
                    pw.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            /**
             * 刷新服务用户列表
             */
            private void refreshUserList() {
                userList.clear();
                for (Socket s : socketList) {
                    ServiceThread st = findServiceThread(s);
                    userList.add(st.username);
                }
            }
    
            /**
             * 向服务用户列表中添加用户
             * @param username
             * @return
             */
            private boolean addUser(String username) {
                if (!canServiceMoreUsers()) {
                    return false;
                }
                return userList.add(username);
            }
    
            /**
             * 查找服务线程
             * @param s
             * @return
             */
            private ServiceThread findServiceThread(Socket s) {
                for (ServiceThread st : ServiceThread.this.socketList) {
                    if (st.socket.equals(s)) {
                        return st;
                    }
                }
                return null;
            }
    
            /**
             * 保存聊天记录
             */
            private void saveRecord() {
                if (recordFile == null) {
                    // 如果之前没有建立聊天记录,则先创建一个新的文件
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.showOpenDialog(Server.this);
                    recordFile = fileChooser.getSelectedFile();
                }
    
                try {
                    OutputStream out = new FileOutputStream(recordFile);
                    for (String s : textArea.getText().split("\n")) {
                        out.write((s + "\n").getBytes());
                    }
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            /**
             * 接收客户端传送的文件,并保存在磁盘中
             */
            private void saveFile() {
                try {
                    String fileName = br.readLine();// 获取传送的文件名
                    String filePath = "C:/SocketData/" + fileName;
                    byte[] buffer = new byte[1024 * 8];
                    File file = new File(filePath);
                    FileOutputStream fos = new FileOutputStream(file);
                    FileInputStream fis = (FileInputStream) socket.getInputStream();
                    int len;
                    while ((len = fis.read(buffer)) != -1) {
                        fos.write(buffer, 0, len);
                    }
                    fos.flush();
                    fis.close();
                    fos.close();
                    printMessage(username + " 上传文件 " + fileName + " 成功!");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
        /**
         * main方法,启动服务器端
         * @param args
         */
        public static void main(String[] args) {
            new Server();
        }
    
    }
    
    

    用户端:

    import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Font;
    import java.awt.Image;
    import java.awt.Toolkit;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.KeyEvent;
    import java.awt.event.KeyListener;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    import javax.swing.BorderFactory;
    import javax.swing.Box;
    import javax.swing.ImageIcon;
    import javax.swing.JButton;
    import javax.swing.JFileChooser;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    import javax.swing.JTextField;
    
    public class Client extends JFrame {
    
        private static final long serialVersionUID = -4622357406573952939L;
    
        private JTextArea chatArea;
        private JTextArea userListArea;
        private JTextField inputField;
        private JButton sendBtn;
        private JButton exitBtn;
        private JButton fileBtn;
    
        private String serverIP = "localhost";
        private int serverPort = 9000;
    
        private String username;
        private Socket socket;
        private BufferedReader br;
        private PrintWriter pw;
    
        public Client() {
            setTitle("客户端");
            setSize(600, 500);
            setLocationRelativeTo(null);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
    
            JPanel panel = new JPanel();
            panel.setLayout(new BorderLayout());
    
            userListArea = new JTextArea();
            userListArea.setEditable(false);
            userListArea.setBorder(BorderFactory.createTitledBorder("服务用户列表"));
            JScrollPane userScroll = new JScrollPane();
            userScroll.setViewportView(userListArea);
            panel.add(userScroll, BorderLayout.EAST);
    
            chatArea = new JTextArea();
            chatArea.setEditable(false);
            chatArea.setLineWrap(true);
            chatArea.setBackground(new Color(240, 240, 240));
            JScrollPane chatScroll = new JScrollPane();
            chatScroll.setViewportView(chatArea);
            panel.add(chatScroll, BorderLayout.CENTER);
    
            Box boxSouth = Box.createHorizontalBox();
    
            inputField = new JTextField(40);
            inputField.addKeyListener(new KeyListener() {
                @Override
                public void keyTyped(KeyEvent e) {
                }
    
                @Override
                public void keyPressed(KeyEvent e) {
                    if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                        sendMessage();
                    }
                }
    
                @Override
                public void keyReleased(KeyEvent e) {
                }
            });
            sendBtn = new JButton("发送");
            sendBtn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    sendMessage();
                }
            });
            exitBtn = new JButton("退出");
            exitBtn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    logout();
                    System.exit(0);
                }
            });
            fileBtn = new JButton("传送文件");
            fileBtn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    chooseFile();
                }
            });
    
            boxSouth.add(inputField);
            boxSouth.add(sendBtn);
            boxSouth.add(Box.createHorizontalStrut(10));
            boxSouth.add(fileBtn);
            boxSouth.add(Box.createHorizontalStrut(10));
            boxSouth.add(exitBtn);
    
            panel.add(boxSouth, BorderLayout.SOUTH);
    
            add(panel);
    
            setVisible(true);
        }
    
        /**
         * 连接到服务器
         * @throws IOException
         */
        public void connect() throws IOException {
            socket = new Socket(serverIP, serverPort);
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
    
            while (true) {
                username = JOptionPane.showInputDialog("请输入你的名字:");
                pw.println("login:" + username);
                pw.flush();
                String serverMsg = br.readLine();
                if (serverMsg.startsWith("login:error")) {
                    JOptionPane.showMessageDialog(this, serverMsg.split(":")[1]);
                } else {
                    break;
                }
            }
    
            setTitle(username);
    
            Thread thread = new Thread(new ReceiveThread());
            thread.start();
        }
    
        /**
         * 退出登录
         */
        public void logout() {
            sendToServer("quit");// 发送退出命令
        }
    
        /**
         * 发送消息到服务器
         */
        private void sendMessage() {
            String msg = inputField.getText();
            sendToServer(msg);
            inputField.setText("");
        }
    
        /**
         * 向服务器发送消息
         * @param msg
         */
        private void sendToServer(String msg) {
            if (msg == null || msg.equals("")) {
                return;
            }
            pw.println(msg);
            pw.flush();
        }
    
        /**
         * 选择文件
         */
        private void chooseFile() {
            JFileChooser fileChooser = new JFileChooser();
            fileChooser.showOpenDialog(this);
            File file = fileChooser.getSelectedFile();
            if (file != null) {
                sendToServer("files");
                sendFile(file);
            }
        }
    
        /**
         * 发送文件
         * @param file
         */
        private void sendFile(File file) {
            try {
                String fileName = file.getName();// 获取文件名
                OutputStream out = socket.getOutputStream();
                FileInputStream fis = new FileInputStream(file);
                byte[] buffer = new byte[1024 * 8];
                int len = 0;
                while ((len = fis.read(buffer)) != -1) {
                    out.write(buffer, 0, len);
                }
                out.flush();
                fis.close();
                chatArea.append(username + " 上传文件 " + fileName + " 成功!\n");// 显示结果
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 接收消息
         * @param msg
         */
        private void receiveMessage(String msg) {
            if (msg.startsWith("showusers:")) {
                userListArea.setText("");
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.