devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用Java实现简易聊天室_java聊天室代码

作者：2023面试高手 | 2024-02-17 02:27:53

赞

踩

java聊天室代码

 

说明：如果一个 类，需要有界面的显示，那么该类就需要继承自JFrame，此时，该类就可以被称为一个“窗体类"。

 

服务端代码：

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

客户端代码：

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

 启动时，必须先启动服务端，再启动客户端。

最终效果：

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/99166
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号