• 超详细带你用Java实现QQ的聊天功能

    38051ee198e84322bd29f5d555caaf31.png

    f0b5ea346cd149e48ceec5cb44cedd9b.gif#pic_center

    个人名片：

    🐼作者简介：一名在校生
    🐻‍❄️个人主页：hmm.
    🕊️系列专栏：零基础学java ----- 重识c语言
    🐓每日一句：只要还有明天，今天就永远是起跑点。

     

     

    第一步：完成界面搭建🐓

    6091766aa0904e5fbe51cc24bead6491.png

    要求：

    • 创建两个窗口：一个客户端，一个服务端，完成代码书写
      步骤：

    1.定义JFrame窗体中的组件：文本域，滚动条，面板，文本框，按钮

    1.  //属性
    2.     //文本域
    3.     private JTextArea jta;
    4.     //滚动条
    5.     private JScrollPane jsp;
    6.     //面板
    7.     private JPanel jp;
    8.     //文本框
    9.     private JTextField jtf;
    10.     //按钮
    11.     private JButton jb;
    12.  
    2.在构造方法中初始化窗口的组件：

    1.  //构造方法
    2.     public ServerChatMain(){
    3.         //初始化组件
    4.         jta = new JTextArea();
    5.         //设置文本域默认不可编辑
    6.         jta.setEditable(false);
    7.         //注意：需要将文本域添加到滚动条中，实现滚动效果
    8.         jsp =new JScrollPane(jta);
    9.         //初始化面板
    10.         jp = new JPanel();
    11.         jtf = new JTextField(10);
    12.         jb=new JButton("发送");
    13.         //注意：需要将文本框与按钮添加到面板中
    14.         jp.add(jtf);
    15.         jp.add(jb);
    16.
    1. 注意：需要将滚动条与面板全部添加到窗体中,继承了窗体的属性，这里this就是窗体
    1.  this.add(jsp, BorderLayout.CENTER);//BorderLayout--边框布局
    2.         this.add(jp,BorderLayout.SOUTH);

    4.设置设置”标题“，大小，位置，关闭，是否可见

    1.    //注意：需要设置”标题“，大小，位置，关闭，是否可见
    2.         this.setTitle("QQ聊天服务端");
    3.         this.setSize(400,300);
    4.         this.setLocation(700,300);
    5.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//窗体关闭，程序就退出
    6.         this.setVisible(true);//设置窗体可见
    7.     }

    这样我们就完成了服务端的QQ聊天界面窗口搭建：
    注意：JTextArea文本域是不可以书写的
    a6cf00c315d1499dbcaa704c96a8d38f.png
    客户端与服务端代码类似，这里就不一一展示了

    书写完毕代码，运行效果如下图：

    32bf5b06843c4c34964daa68ddb44033.png

    afdc987b6bef4dfbb31fc38f805cb23d.png

    第二步：TPC通信的思路与步骤🐻‍❄️

    使用网络编程完成数据点的传输（TCP，UDP协议）

    TCP协议🐶

    TCP 是面向连接的运输层协议。应用程序在使用 TCP 协议之前，必须先建立 TCP 连接。在传送数据完毕后，必须释放已经建立的 TCP 连接
    每一条 TCP 连接只能有两个端点，每一条 TCP 连接只能是点对点的(一对一)
    TCP 提供可靠交付的服务。通过 TCP 连接传送的数据，无差错、不丢失、不重复，并且按序到达
    TCP 提供全双工通信。TCP 允许通信双方的应用进程在任何时候都能发送数据。TCP 连接的两端都设有发送缓存和接受缓存，用来临时存放双向通信的数据
    面向字节流。TCP 中的“流”指的是流入到进程或从进程流出的字节序列
    4a76e73a354a4b75bca59c0eb13b5782.png
    b1ee168f384d4d419db72cd683b00bc8.png

    TCP 服务端 具体步骤(客户端类似)🐮

    具体步骤：

    •    1.创建一个服务端的套接字

    •     2.等待客户端连接

    •    3.获取socket通道的输入流(输入六是实现读取数据的，一行一行读取)BufferedReader->readLine();

    •     4.获取socket 通道的输出流(输出流实现写出数据，也是写一行换一行，刷新)BufferedWriter->newLine();

    •     5.关闭socket 通道

    TCP通信步骤代码实现：🐸

    1.  try {
    2.             //1.创建一个服务端的套接字
    3.             ServerSocket serverSocket = new ServerSocket(8888);
    4.  
    5.             //2.等待客户端连接
    6.            Socket socket = serverSocket.accept();
    7.  
    8.             //3.获取socket通道的输入流(输入六是实现读取数据的，一行一行读取)BufferedReader->readLine();
    9.             //InputStream in = socket.getInputStream();
    10.            BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
    11.             //4.获取socket 通道的输出流(输出流实现写出数据，也是写一行换一行，刷新)BufferedWriter->newLine();
    12.             //当用户点击发送按钮的时候写出数据
    13.             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    14.  
    15.             //循环读取数据并拼接到文本域
    16.             String line = null;
    17.            while((line = br.readLine())!=null){
    18.                //将读取的数据拼接到文本域中显示
    19.                jta.append(line+System.lineSeparator());
    20.            }
    21.  
    22.  
    23.             //5.关闭socket 通道
    24.             serverSocket.close();
    25.  
    26.         }catch (IOException e) {
    27.             e.printStackTrace();
    28.         }
    29.

    点击发送按钮实现数据的传输🐺

    1.  @Override
    2.     public void actionPerformed(ActionEvent actionEvent) {
    3.         System.out.println("发送按钮被点击了");
    4.     }

    步骤：

    1.获取文本框中发送的内容
    2.拼接需要发送的数据内容
    3.自己也要显示
    4.发送
    5.清空文本框内容

    1. @Override
    2.     public void actionPerformed(ActionEvent actionEvent) {
    3.         //System.out.println("发送按钮被点击了");
    4.         //1.获取文本框中发送的内容
    5.         String text = jtf.getText();
    6.         //2.拼接需要发送的数据内容
    7.         text = "服务端对客户端说："+text;
    8.         //3.自己也要显示
    9.         jta.append(text);
    10.         //4.发送
    11.         try {
    12.             bw.write(text);
    13.             bw.newLine();//换行刷新
    14.             bw.flush();
    15.             //5.清空文本框内容
    16.             jtf.setText("");
    17.         } catch (IOException e) {
    18.             e.printStackTrace();
    19.         }
    20.  
    21.  
    22.     }
    23.

    680886e93e04472bbf1732e71b4cff82.gif#pic_center

    第三步：实现回车键发送数据（客户端类似）🐳

    首先要实现一个接口

    public class ClientChatMain extends JFrame implements ActionListener, KeyListener {

    1. @Override
    2.     public void keyPressed(KeyEvent e) {
    3.  
    4.         //回车键
    5.         // System.out.println(e);
    6.         //发送数据到socket 同道中
    7.         if(e.getKeyCode()==KeyEvent.VK_ENTER) {
    8.         sendDataToSocket();
    9.     }

    e1f9fe1f69bd4d3b94c348a124630b49.gif#pic_center

    全部代码：🐲

    服务端：

    1. package com.ithmm.chat;
    2.  
    3. import javax.swing.*;
    4. import java.awt.*;
    5. import java.awt.event.ActionEvent;
    6. import java.awt.event.ActionListener;
    7. import java.awt.event.KeyEvent;
    8. import java.awt.event.KeyListener;
    9. import java.io.*;
    10. import java.net.ServerSocket;
    11. import java.net.Socket;
    12. import java.util.Properties;
    13.  
    14. //说明：如果一个类，需要有界面的显示，那么这个类就需要继承JFrame，此时，该类可以被成为一个窗体类
    15. /*步骤：
    16.      1.定义JFrame窗体中的组件
    17.      2.在构造方法中初始化窗口的组件
    18.      3.使用网络编程完成数据的链接(TPC,UDP  协议)
    19.      4.实现"发送”按钮的监听点击事件
    20.      5.实现“回车键”发送数据
    21.  */
    22. public class ServerChatMain extends JFrame implements ActionListener, KeyListener {
    23.     public static void main(String[] args) {
    24.  
    25.         //调用构造方法
    26.         new ServerChatMain();
    27.     }
    28.  
    29.     //属性
    30.     //文本域
    31.     private JTextArea jta;
    32.     //滚动条
    33.     private JScrollPane jsp;
    34.     //面板
    35.     private JPanel jp;
    36.     //文本框
    37.     private JTextField jtf;
    38.     //按钮
    39.     private JButton jb;
    40.     //输出流(成员变量)
    41.     private BufferedWriter bw = null;
    42.     //服务端的端口号
    43.     //private static int serverPort;
    44.  
    45.     //使用static静态方法读取外部京台文件
    46.     //static代码块特点：1.在类加载的时候自动执行
    47.     //特点2：一个类会被加载一次，因此静态代码块在程序中仅会被执行一次
    48.  
    49.     /*static{
    50.         Properties prop = new Properties();
    52.         try {
    53.             //加载
    54.             prop.load(new FileReader("chat.properties"));
    56.             //给属性赋值
    57.             Integer.parseInt(prop.getProperty("serverPort"));
    58.         } catch (IOException e) {
    59.             e.printStackTrace();
    60.         }
    61.     }*/
    62.     //构造方法
    63.     public ServerChatMain(){
    64.         //初始化组件
    65.         jta = new JTextArea();
    66.         //设置文本域默认不可编辑
    67.         jta.setEditable(false);
    68.         //注意：需要将文本域添加到滚动条中，实现滚动效果
    69.         jsp =new JScrollPane(jta);
    70.         //初始化面板
    71.         jp = new JPanel();
    72.         jtf = new JTextField(10);
    73.         jb=new JButton("发送");
    74.         //注意：需要将文本框与按钮添加到面板中
    75.         jp.add(jtf);
    76.         jp.add(jb);
    77.  
    78.         //注意：需要将滚动条与面板全部添加到窗体中,继承了窗体的属性，这里this就是窗体
    79.         this.add(jsp, BorderLayout.CENTER);//BorderLayout--边框布局
    80.         this.add(jp,BorderLayout.SOUTH);
    81.  
    82.         //注意：需要设置”标题“，大小，位置，关闭，是否可见
    83.         this.setTitle("QQ聊天服务端");
    84.         this.setSize(400,300);
    85.         this.setLocation(700,300);
    86.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//窗体关闭，程序就退出
    87.         this.setVisible(true);//设置窗体可见
    88.  
    89.         /**************** TCP   服务端    Start *********************/
    90.         //给发送按钮绑定一个监听点击事件
    91.         jb.addActionListener(this);
    92.         //给文本框绑定一个键盘点击事件
    93.         jtf.addKeyListener(this);
    94.  
    95.         try {
    96.             //1.创建一个服务端的套接字
    97.             ServerSocket serverSocket = new ServerSocket(8888);
    98.  
    99.             //2.等待客户端连接
    100.            Socket socket = serverSocket.accept();
    101.  
    102.             //3.获取socket通道的输入流(输入六是实现读取数据的，一行一行读取)BufferedReader->readLine();
    103.             //InputStream in = socket.getInputStream();
    104.            BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
    105.             //4.获取socket 通道的输出流(输出流实现写出数据，也是写一行换一行，刷新)BufferedWriter->newLine();
    106.             //当用户点击发送按钮的时候写出数据
    107.             bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    108.  
    109.             //循环读取数据并拼接到文本域
    110.             String line = null;
    111.            while((line = br.readLine())!=null){
    112.                //将读取的数据拼接到文本域中显示
    113.                jta.append(line+System.lineSeparator());
    114.            }
    115.  
    116.  
    117.             //5.关闭socket 通道
    118.             serverSocket.close();
    119.  
    120.         }catch (IOException e) {
    121.             e.printStackTrace();
    122.         }
    123.  
    124.         /**************** TCP   服务端    end  *********************/
    125.     }
    126.  
    127.     @Override
    128.     public void actionPerformed(ActionEvent actionEvent) {
    129.         //System.out.println("发送按钮被点击了");
    130.        sendDataToSocket();
    131.     }
    132.     //行为
    133.     @Override
    134.     public void keyPressed(KeyEvent e) {
    135.  
    136.         //回车键
    137.         // System.out.println(e);
    138.         //发送数据到socket 同道中
    139.         if(e.getKeyCode()==KeyEvent.VK_ENTER) {
    140.             sendDataToSocket();
    141.         }
    142.     }
    143.     //定义一个方法，实现将数据发送到socket通道中
    144.     private void sendDataToSocket(){
    145.         //1.获取文本框中发送的内容
    146.         String text = jtf.getText();
    147.         //2.拼接需要发送的数据内容
    148.         text = "服务端对客户端说："+text;
    149.         //3.自己也要显示
    150.         jta.append(text+System.lineSeparator());
    151.         //4.发送
    152.         try {
    153.             bw.write(text);
    154.             bw.newLine();//换行刷新
    155.             bw.flush();
    156.             //5.清空文本框内容
    157.             jtf.setText("");
    158.         } catch (IOException e) {
    159.             e.printStackTrace();
    160.         }
    161.  
    162.     }
    163.  
    164.     @Override
    165.     public void keyTyped(KeyEvent keyEvent) {
    166.  
    167.     }
    168.  
    169.  
    170.  
    171.     @Override
    172.     public void keyReleased(KeyEvent keyEvent) {
    173.  
    174.     }
    175.  
    176.  
    177.  
    178. }
    179.

    客户端：

    1.  
    2. import javax.swing.JButton;
    3. import javax.swing.JFrame;
    4. import javax.swing.JPanel;
    5. import javax.swing.JScrollPane;
    6. import javax.swing.JTextArea;
    7. import javax.swing.JTextField;
    8. import java.awt.BorderLayout;
    9. import java.awt.event.ActionEvent;
    10. import java.awt.event.ActionListener;
    11. import java.awt.event.KeyEvent;
    12. import java.awt.event.KeyListener;
    13. import java.io.BufferedReader;
    14. import java.io.BufferedWriter;
    15. import java.io.IOException;
    16. import java.io.InputStreamReader;
    17. import java.io.OutputStreamWriter;
    18. import java.net.Socket;
    19. import java.util.Properties;
    20.  
    21. //说明：如果一个类，需要有界面的显示，那么这个类就需要继承JFrame，此时，该类可以被成为一个窗体类
    22. /*步骤：
    23.      1.定义JFrame窗体中的组件
    24.      2.在构造方法中初始化窗口的组件
    25.  */
    26.  
    27. public class ClientChatMain extends JFrame implements ActionListener, KeyListener {
    28.     public static void main(String[] args) {
    29.  
    30.         //调用构造方法
    31.         new ClientChatMain();
    32.     }
    33.  
    34.     //属性
    35.     //文本域
    36.     private JTextArea jta;
    37.     //滚动条
    38.     private JScrollPane jsp;
    39.     //面板
    40.     private JPanel jp;
    41.     //文本框
    42.     private JTextField jtf;
    43.     //按钮
    44.     private JButton jb;
    45.     //s输出流
    46.     private BufferedWriter bw =null;
    47.     //客户端的IP地址
    48.    // private static String clientIp;
    49.     //客户端的port端口号
    50.  
    51.    // private static int clientPort;
    52.  
    53.     //静态代码块加载外部配置文件
    54.    /* static{
    55.       Properties prop = new Properties();
    56.         try {
    57.             prop.load(new FileReader("chat.properties"));
    58.             clientIp = prop.getProperty("clientIp");
    59.             clientPort =Integer.parseInt( prop.getProperty("clientPort"));
    60.         } catch (IOException e) {
    61.             e.printStackTrace();
    62.         }
    63.     }*/
    64.     //构造方法
    65.     public ClientChatMain(){
    66.         //初始化组件
    67.         jta = new JTextArea();
    68.         //设置文本域默认不可编辑
    69.         jta.setEditable(false);
    70.         //注意：需要将文本域添加到滚动条中，实现滚动效果
    71.         jsp =new JScrollPane(jta);
    72.         //初始化面板
    73.         jp = new JPanel();
    74.         jtf = new JTextField(10);
    75.         jb=new JButton("发送");
    76.         //注意：需要将文本框与按钮添加到面板中
    77.         jp.add(jtf);
    78.         jp.add(jb);
    79.  
    80.         //注意：需要将滚动条与面板全部添加到窗体中,继承了窗体的属性，这里this就是窗体
    81.         this.add(jsp, BorderLayout.CENTER);//BorderLayout--边框布局
    82.         this.add(jp,BorderLayout.SOUTH);
    83.  
    84.         //注意：需要设置”标题“，大小，位置，关闭，是否可见
    85.         this.setTitle("QQ聊天客户端");
    86.         this.setSize(400,300);
    87.         this.setLocation(700,300);
    88.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//窗体关闭，程序就退出
    89.         this.setVisible(true);//设置窗体可见
    90.  
    91.         /**************** TCP   客户端    Start *********************/
    92.  
    93.         //给发送按钮绑定一个监听点击事件
    94.         jb.addActionListener(this);
    95.         //给文本框绑定一个键盘键
    96.         jtf.addKeyListener(this);
    97.         try {
    98.             //1.创建一个客户端的套接字(尝试连接）
    99.  
    100.             Socket socket = new Socket("127.0.0.1",8888);
    101.  
    102.             //2.获取socket通道的输入流
    103.            BufferedReader br =  new BufferedReader(new InputStreamReader(socket.getInputStream()));
    104.             //3.获取socket 通道的输出流
    105.           bw =  new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    106.             //循环读取数据，并拼接到文本域
    107.            String line = null;
    108.            while((line = br.readLine())!=null){
    109.                jta.append(line + System.lineSeparator());
    110.            }
    111.  
    112.             //4.关闭socket 通道
    113.             socket.close();
    114.         }catch (Exception e){
    115.             e.printStackTrace();
    116.         }
    117.  
    118.         /**************** TCP   客户端    end  *********************/
    119.     }
    120.  
    121.     @Override
    122.     public void actionPerformed(ActionEvent e) {
    123.        sendDataToSocket();
    124.     }
    125.     //行为
    126.     @Override
    127.     public void keyPressed(KeyEvent e) {
    128.         //回车键
    129.         if(e.getKeyCode() == KeyEvent.VK_ENTER){
    130.             //发送数据
    131.             sendDataToSocket();
    132.         }
    133.  
    134.     }
    135.     private void sendDataToSocket(){
    136.         //1.获取文本框需要发送内容
    137.         String text = jtf.getText();
    138.  
    139.         //2.拼接内容
    140.  
    141.         text = "客户端对服务端说"+text;
    142.  
    143.         //3.自己显示
    144.         jta.append(text+System.lineSeparator());
    145.  
    146.         try {
    147.             //4.发送
    148.             bw.write(text);
    149.             bw.newLine();//换行加刷新
    150.             bw.flush();
    151.  
    152.             bw.write(text);
    153.             //5.清空
    154.             jtf.setText("");
    155.         } catch (IOException e) {
    156.             e.printStackTrace();
    157.         }
    158.  
    159.     }
    160.     @Override
    161.     public void keyTyped(KeyEvent e) {
    162.  
    163.     }
    164.  
    165.     @Override
    166.     public void keyReleased(KeyEvent e) {
    167.  
    168.     }
    169.  
    170. }
    171.

    接口类：

    1. public interface addActistener {
    2. }
    1. public interface addActionListener {
    2. }

    90918e157acf4f61bbb7f4f478223ed9.gif#pic_center
    兄弟们，三连支持一下！！！

     

  • 相关阅读:
    Leetcode 2099. Find Subsequence of Length K With the Largest Sum [Python]
    Android监听应用切换到后台和前台
    Boost ASIO：Network programming
    Vivado使用记录（未完待续）
    【Docker】从零开始：4.为什么Docker会比VM虚拟机快
    1095 Cars on Campus
    栈题目：有效括号的嵌套深度
    C：vprintf/vfprintf/vdprintf/vsprintf/vsnprintf，对可变参数的支持
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java影院售票系统6fg71
    什么是枚举类型？如何定义和使用枚举？
  • 原文地址：https://blog.csdn.net/m0_68089732/article/details/124897209