巧妙利用java实现在线聊天系统教程方法

逃离我推掉我的手 2023-09-26 19:57 81阅读 0赞

一、搭建服务器端

a)、创建ServerSocket对象绑定监听端口。  
b)、通过accept()方法监听客户端的请求。  
c)、建立连接后，通过输入输出流读取客户端发送的请求信息。  
d)、通过输出流向客户端发送请求信息。  
e)、关闭相关资源。

二、搭建客户器端

a)、创建Socket对象，指明需要连接的服务器的地址和端口。  
b)、建立连接后，通过输出流向服务器发送请求信息。  
c)、通过输入流获取服务器的响应信息。  
d)、关闭响应资源

代码展示  
服务器端代码：

import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.EOFException;  
import java.io.IOException;  
import java.net.BindException;  
import java.net.ServerSocket;  
import java.net.Socket;  
import java.net.SocketException;  
import java.util.ArrayList;

/\*\*

*  版本三：转发给其他的客户端 1.保存每一个客户端的连接
 *

\*/  
public class ChatSeverEdition3 \{  
// 服务器端是否启动  
boolean started = false;  
ServerSocket serverSocket = null;  
ArrayList clients = new ArrayList();

public static void main(String[] args) {
    
        new ChatSeverEdition3().start();
    }
    
    public void start() {
    
        try {
            serverSocket = new ServerSocket(8888);
            started = true;
        } catch (BindException e) {
            // 多次启动服务器
            System.out.println("端口使用中。。。。");
            System.out.println("请关掉相关程序，并重新运行服务器！");
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
        }
    
        try {
    
            while (started) {
                // 客户端是否连接
                Socket socket = serverSocket.accept();
                // main()方法是static方法，不能在其中new动态类Client
                Client client = new Client(socket);
                // 线程启动
                new Thread(client).start();
                // 将当前启动的客户端保存下来
                clients.add(client);
                System.out.println("new Client成功！");
                System.out.println("A Client connected!");
    
    
            }
    
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 
     * 
     *
     */
    class Client implements Runnable {
        private Socket s;
        private DataInputStream dis = null;
        private boolean bConnected = false;
        private DataOutputStream dos;
    
        public Client(Socket s) {
            this.s = s;
    
            try {
                dis = new DataInputStream(s.getInputStream());
                dos = new DataOutputStream(s.getOutputStream());
                bConnected = true;
                System.out.println("有一个新的客户端程序在运行");
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 一个客户端连接成功以后，一直在执行该while部分的代码，其他客户端无法连接
            /**
             * 解决方法： 1.异步解决方法：一直监听接收，其他在另外的地方执行 2.使用单独的线程： 线程：接受客户端连接
             * 另外的单独的线程：处理通讯
             */
    
        }
    
        public void sendString(String str) {
            try {
                dos.writeUTF(str);
            } catch (IOException e) {
                clients.remove(this);
                System.out.println("对方退出了！！！我从List中去掉了！！！");
            }
        }
    
        public void run() {
            Client client = null;
            // 注意这部分的包围关系
            try {
                while (bConnected) {
                    String string = dis.readUTF();
                    System.out.println(string);
                    for (int i = 0; i < clients.size(); i++) {
                        client = clients.get(i);
                        client.sendString(string);
                    }
                }
            } catch (EOFException e) {
                System.out.println("Client closed!");
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(0);
    
            } finally {
                try {
                    if (dis != null) {
                        dis.close();
                    }
                    if (s != null) {
                        s.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
    }

\}  
客户端代码：

import java.awt.BorderLayout;  
import java.awt.Frame;  
import java.awt.TextArea;  
import java.awt.TextField;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import java.awt.event.WindowAdapter;  
import java.awt.event.WindowEvent;  
import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.EOFException;  
import java.io.IOException;  
import java.net.BindException;  
import java.net.Socket;  
import java.net.SocketException;  
import java.net.UnknownHostException;

/\*\*

*  可以和ChatServer版本三配套使用
 *  
 *  @author Administrator
 *

\*/  
public class ChatClientEdition3 extends Frame \{  
TextField tfText = new TextField();  
TextArea taContent = new TextArea();  
Socket socket = null;  
DataOutputStream dataOutputStream = null;  
DataInputStream dataInputStream = null;  
private boolean bConnected = false;

public static void main(String[] args) {
    
        new ChatClientEdition3().launchFrame();
    }
    
    // 加载窗口
    public void launchFrame() {
        setLocation(400, 300);
        this.setSize(300, 300);
        this.setTitle("在线聊天时--Quiana");
        add(tfText, BorderLayout.SOUTH);
        add(taContent, BorderLayout.NORTH);
        pack();
        // 窗口关闭的时间监听
        this.addWindowListener(new WindowAdapter() {
    
            @Override
            public void windowClosing(WindowEvent e) {
                disconnect();
                System.exit(0);
            }
    
        });
        tfText.addActionListener(new TFListener());
        this.setVisible(true);
        connect();
        new Thread(new RecvThread()).start();
    }
    
    // 文字处理的时间监听
    private class TFListener implements ActionListener {
        // 敲击回车时，文字的变化事件
        @Override
        public void actionPerformed(ActionEvent arg0) {
            String s = tfText.getText().trim(); // 去掉两端的空格
            tfText.setText("");
            try {
    
                dataOutputStream.writeUTF(s);
                dataOutputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
    }
    
    // 连接到服务器
    public void connect() {
        try {
            // 连接到服务器
            socket = new Socket("127.0.0.1", 8888);
            bConnected = true;
            dataOutputStream = new DataOutputStream(socket.getOutputStream());
            dataInputStream = new DataInputStream(socket.getInputStream());
            System.out.println("连接到服务器！！！");
        } catch (BindException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // 断开连接
    public void disconnect() {
        try {
            dataOutputStream.close();
            System.out.println("dataOutputStream成功关闭");
            socket.close();
            System.out.println("客户端socket成功关闭");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private class RecvThread implements Runnable {
    
        public void run() {
    
            try {
                while (bConnected) {
                    String string = dataInputStream.readUTF();
                    if (taContent.getText().length() == 0) {
                        taContent.setText(string);
                    } else {
                        taContent.setText(taContent.getText() + "\n" + string);
                    }
                }
            } catch (SocketException e) {
                System.out.println("退出了，拜拜！");
            } catch (EOFException e) {
                System.out.println("退出了，拜拜！");
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
    }

\}  
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。