devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

网络聊天程序的设计与实现——计网课设_基于winsocket的网络群聊程序的设计与实现

作者：笔触狂放9 | 2024-06-16 20:48:47

赞

踩

基于winsocket的网络群聊程序的设计与实现

  • 实验题目

网络聊天程序的设计与实现

  • 实验目的

使用socket编程，了解socket编程的通信原理，会使用socket进行简单的网络编程，在此基础上编写一聊天程序，能够运行程序，运行客户端和服务器端，实现两个客户端通过服务器端进行通信。

  • 总体设计

1、背景知识

1.1 Tcp协议与Win Sock网络编程接口：

Tcp协议： 是面向连接的运输层协议，提供可靠的、有序的、双向的、面向连接的运输服务。

Win Sock编程： 是一种网络编程接口，实际上是作为TCP/IP协议的一种封装。可以通过调用WinSock的接口函数来调用TCP/IP的各种功能。

WinSock 编程简单流程：WinSock编程分为服务器端和客户端两部分。

2、实现的功能

1、显示上线下线时间  

2、服务端监听上线的客户端的IP和端口号

3、一个客户端发消息后(注：客户端在java编译器的终端输入消息)服务器能接收并转发消息给其他客户端     

4、清屏

如何在局域网中使用：  修改客户端代码中的  private final String HOST = "127.0.0.1" 改为接入的局域网服务器的IP即可

3、代码

  1. package GroupChat;
  2.  
  3. import javax.swing.*;
  4. import javax.swing.table.DefaultTableModel;
  5. import javax.swing.table.TableModel;
  6. import java.awt.*;
  7. import java.awt.event.ActionEvent;
  8. import java.awt.event.ActionListener;
  9. import java.awt.event.MouseEvent;
  10. import java.awt.event.MouseListener;
  11. import java.io.OutputStream;
  12. import java.text.SimpleDateFormat;
  13. import java.util.ArrayList;
  14. import java.util.Date;
  15.  
  16. class ClientFrame extends JFrame {
  17.  
  18.     //时间显示格式
  19.     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  20.  
  21.     //窗口宽度
  22.     final int WIDTH = 700;
  23.     //窗口高度
  24.     final int HEIGHT = 600;
  25.  
  26.     //创建发送按钮
  27.     JButton btnSend = new JButton("发送");
  28.     //创建清除按钮
  29.     JButton btnClear = new JButton("清屏");
  30.     //创建退出按钮
  31.     JButton btnExit = new JButton("退出");
  32.  
  33.     //创建聊天消息框
  34.     JTextArea jtaChat = new JTextArea();
  35.  
  36.     //当前在线列表的列标题
  37.     String[] colTitles = {"IP", "端口"};
  38.     //当前在线列表的数据,暂存在动态数组中
  39.     String[][] rowDatatrue;
  40.  
  41.     public void setRowData(String address,String port){
  42.         String[] newaddress = {address,port};
  43.         jtaChat.append(sdf.format(new Date()) + "\n: " + address+":"+port  + "上线了\n");
  44.         DefaultTableModel  model = (DefaultTableModel)jtbOnline.getModel();
  45.         model.addRow(new Object[]{newaddress[0],newaddress[1]});
  46.         jtbOnline.setModel(model);
  47.     }
  48.     public void addinfo(String msg){
  49.         jtaChat.append(sdf.format(new Date()) + "\n: " + msg.trim() +"\n");
  50.  
  51.     }
  52.  
  53.     public void delRowData(String address,String port){
  54.         String[] deladdress = {address,port};
  55.         jtaChat.append(sdf.format(new Date()) + "\n: " + address+":"+port  + "离线了\n");
  56.         DefaultTableModel  model = (DefaultTableModel)jtbOnline.getModel();
  57.         int rowcount= model.getRowCount();
  58.         for(int i=0;i<rowcount;i++){
  59.             if(model.getValueAt(i,1).equals(deladdress[1])){
  60.                 model.removeRow(i);
  61.                 break;
  62.             }
  63.         }
  64.         model.fireTableDataChanged();
  65.     }
  66.  
  67.     //创建当前在线列表
  68.     JTable jtbOnline = new JTable
  69.             (
  70.                     new DefaultTableModel(rowDatatrue, colTitles) {
  71.                         //表格不可编辑，只可显示
  72.                         @Override
  73.                         public boolean isCellEditable(int row, int column) {
  74.                             return false;
  75.                         }
  76.                     }
  77.             );
  78.  
  79.     //创建聊天消息框的滚动窗
  80.     JScrollPane jspChat = new JScrollPane(jtaChat);
  81.  
  82.     //创建当前在线列表的滚动窗
  83.     JScrollPane jspOnline = new JScrollPane(jtbOnline);
  84.  
  85.     //设置默认窗口属性，连接窗口组件
  86.     public ClientFrame() {
  87.         //标题
  88.         setTitle("聊天室");
  89.         //大小
  90.         setSize(WIDTH, HEIGHT);
  91.         //不可缩放
  92.         setResizable(false);
  93.         //设置布局:不适用默认布局，完全自定义
  94.         setLayout(null);
  95.  
  96.         //设置按钮大小和位置
  97.         btnClear.setBounds(140, 420, 100, 60);
  98.  
  99.  
  100.  
  101.         //设置按钮文本的字体
  102.         btnClear.setFont(new Font("宋体", Font.BOLD, 18));
  103.  
  104.         //添加按钮
  105.  
  106.         this.add(btnClear);
  107.  
  108.  
  109.         //聊天消息框自动换行
  110.         jtaChat.setLineWrap(true);
  111.         //聊天框不可编辑，只用来显示
  112.         jtaChat.setEditable(false);
  113.         //设置聊天框字体
  114.         jtaChat.setFont(new Font("楷体", Font.BOLD, 16));
  115.  
  116.         //设置滚动窗的水平滚动条属性:不出现
  117.         jspChat.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
  118.         //设置滚动窗的垂直滚动条属性:需要时自动出现
  119.         jspChat.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
  120.         //设置滚动窗大小和位置
  121.         jspChat.setBounds(20, 20, 360, 400);
  122.         //添加聊天窗口的滚动窗
  123.         this.add(jspChat);
  124.  
  125.         //设置滚动窗的水平滚动条属性:不出现
  126.         jspOnline.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
  127.         //设置滚动窗的垂直滚动条属性:需要时自动出现
  128.         jspOnline.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
  129.         //设置当前在线列表滚动窗大小和位置
  130.         jspOnline.setBounds(420, 20, 250, 400);
  131.         //添加当前在线列表
  132.         this.add(jspOnline);
  133.  
  134.         //添加清屏按钮的响应事件
  135.         btnClear.addActionListener
  136.                 (
  137.                         new ActionListener() {
  138.                             @Override
  139.                             public void actionPerformed(ActionEvent event) {
  140.                                 //聊天框清屏
  141.                                 jtaChat.setText("");
  142.                             }
  143.                         }
  144.                 );
  145.  
  146.         this.show();
  147.     }
  148. }

客户端（想要几个客户就创建几个客户端） 

  1. package GroupChat;
  2.  
  3. import java.io.IOException;
  4. import java.net.InetSocketAddress;
  5. import java.nio.ByteBuffer;
  6. import java.nio.channels.SelectionKey;
  7. import java.nio.channels.Selector;
  8. import java.nio.channels.SocketChannel;
  9. import java.util.Iterator;
  10. import java.util.Scanner;
  11.  
  12. public class GroupChatClient {
  13.     private final String HOST = "127.0.0.1";//服务器的ip
  14.     private final int PORT = 6667;//服务器端口
  15.     private Selector selector;
  16.     private SocketChannel socketChannel;
  17.     private String username;
  18.  
  19.     //构造器,完成初始化工作
  20.     public GroupChatClient() throws IOException {
  21.  
  22.         selector = Selector.open();
  23.         //连接服务器
  24.         socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
  25.         //设置非阻塞
  26.         socketChannel.configureBlocking(false);
  27.         //将 channel 注册到selector
  28.         socketChannel.register(selector, SelectionKey.OP_READ);
  29.         //得到 username
  30.         username = socketChannel.getLocalAddress().toString().substring(1);
  31.         System.out.println(username + " is ok...");
  32.     }
  33.  
  34.     //向服务器发送消息
  35.     public void sendInfo(String info) {
  36.         info = username + " 说：" + info;
  37.         try {
  38.             socketChannel.write(ByteBuffer.wrap(info.getBytes()));
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.  
  44.     //读取从服务器端回复的消息
  45.     public void readInfo() {
  46.         try {
  47.             int readChannels = selector.select();
  48.             if (readChannels > 0) {//有可以用的通道
  49.                 Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  50.                 while (iterator.hasNext()) {
  51.                     SelectionKey key = iterator.next();
  52.                     if (key.isReadable()) {
  53.                         //得到相关的通道
  54.                         SocketChannel sc = (SocketChannel) key.channel();
  55.                         //得到一个 Buffer
  56.                         ByteBuffer buffer = ByteBuffer.allocate(1024);
  57.                         //读取
  58.                         sc.read(buffer);
  59.                         //把读到的缓冲区的数据转成字符串
  60.                         String msg = new String(buffer.array());
  61.                         System.out.println(msg.trim());
  62.                     }
  63.                 }
  64.                 iterator.remove(); //删除当前的 selectionKey,防止重复操作
  65.             } else {
  66.                 //System.out.println("没有可以用的通道...");
  67.             }
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         }
  71.     }
  72.  
  73.     public static void main(String[] args) throws Exception {
  74.  
  75.         //启动我们客户端
  76.         GroupChatClient chatClient = new GroupChatClient();
  77.         //启动一个线程,每个 3 秒，读取从服务器发送数据
  78.         new Thread() {
  79.             public void run() {
  80.                 while (true) {
  81.                     chatClient.readInfo();
  82.                     try {
  83.                         Thread.currentThread().sleep(3000);
  84.                     } catch (InterruptedException e) {
  85.                         e.printStackTrace();
  86.                     }
  87.                 }
  88.             }
  89.         }.start();
  90.  
  91.         //发送数据给服务器端
  92.         Scanner scanner = new Scanner(System.in);
  93.         while (scanner.hasNextLine()) {
  94.             String s = scanner.nextLine();
  95.             chatClient.sendInfo(s);
  96.         }
  97.     }
  98. }
  99.

 服务器端

  1. package GroupChat;
  2. // 服务端：
  3.  
  4. import java.io.IOException;
  5. import java.net.InetSocketAddress;
  6. import java.nio.ByteBuffer;
  7. import java.nio.channels.Channel;
  8. import java.nio.channels.SelectionKey;
  9. import java.nio.channels.Selector;
  10. import java.nio.channels.ServerSocketChannel;
  11. import java.nio.channels.SocketChannel;
  12. import java.util.Iterator;
  13.  
  14. public class GroupChatServer {
  15.  
  16.     //定义属性
  17.     private Selector selector;
  18.     private ServerSocketChannel listenChannel;
  19.     private ClientFrame clientFrame;
  20.  
  21.     private static final int PORT = 6667;
  22.  
  23.     //构造器
  24.     //初始化工作
  25.     public GroupChatServer() {
  26.         clientFrame = new ClientFrame();
  27.         try {
  28.             //得到选择器
  29.             selector = Selector.open();
  30.             //ServerSocketChannel
  31.             listenChannel = ServerSocketChannel.open();
  32.             //绑定端口
  33.             listenChannel.socket().bind(new InetSocketAddress(PORT));
  34.             //设置非阻塞模式
  35.             listenChannel.configureBlocking(false);
  36.             //将该 listenChannel 注册到 selector
  37.             listenChannel.register(selector, SelectionKey.OP_ACCEPT);
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42.  
  43.     public void listen() {
  44.         try {
  45.             //循环处理
  46.             while (true) {
  47.                 int count = selector.select();
  48.                 if (count > 0) { //有事件处理
  49.                     // 遍历得到 selectionKey 集合
  50.                     Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  51.                     while (iterator.hasNext()) {
  52.                         //取出 selectionkey
  53.                         SelectionKey key = iterator.next();
  54.                         //监听到 accept
  55.                         if (key.isAcceptable()) {
  56.                             SocketChannel sc = listenChannel.accept();
  57.                             sc.configureBlocking(false);
  58.                             //将该 sc 注册到 seletor
  59.                             sc.register(selector, SelectionKey.OP_READ);
  60.                             //提示
  61. //                            System.out.println(sc.getRemoteAddress() + " 上线 ");
  62.                             String remoteaddress = sc.getRemoteAddress().toString();
  63.                             String[] split = remoteaddress.split(":");
  64.  
  65.                             clientFrame.setRowData(split[0],split[1]);
  66.  
  67.                         }
  68.                         if (key.isReadable()) {//通道发送read事件，即通道是可读的状态
  69.                             // 处理读(专门写方法..)
  70.                             readData(key);
  71.                         }
  72.                         //当前的 key 删除，防止重复处理
  73.                         iterator.remove();
  74.                     }
  75.                 } else {
  76.                     System.out.println("等待....");
  77.                 }
  78.             }
  79.         } catch (Exception e) {
  80.             e.printStackTrace();
  81.         } finally {
  82.             //发生异常处理....
  83.         }
  84.     }
  85.  
  86.     //读取客户端消息
  87.     public void readData(SelectionKey key) {
  88.         SocketChannel channel = null;
  89.         try {
  90.             //得到 channel
  91.             channel = (SocketChannel) key.channel();
  92.             //创建 buffer
  93.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  94.             int count = channel.read(buffer);
  95.             //根据 count 的值做处理
  96.             if (count > 0) {
  97.                 //把缓存区的数据转成字符串
  98.                 String msg = new String(buffer.array());
  99.                 //输出该消息
  100.                 System.out.println("form客户端:" + msg);
  101.                 clientFrame.addinfo(msg);
  102.                 //向其它的客户端转发消息(去掉自己),专门写一个方法来处理
  103.                 sendInfoToOtherClients(msg, channel);
  104.             }
  105.         } catch (IOException e) {
  106.             try {
  107.                 System.out.println(channel.getRemoteAddress() + "离线了..");
  108.                 String remoteaddress = channel.getRemoteAddress().toString();
  109.                 String[] split = remoteaddress.split(":");
  110.                 clientFrame.delRowData(split[0],split[1]);
  111.                 //取消注册
  112.                 key.cancel();
  113.                 //关闭通道
  114.                 channel.close();
  115.             } catch (IOException e2) {
  116.                 e2.printStackTrace();
  117.             }
  118.         }
  119.     }
  120.  
  121.     //转发消息给其它客户(通道)
  122.     private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
  123.  
  124.         System.out.println("服务器转发消息中...");
  125.         //遍历所有注册到 selector 上的 SocketChannel,并排除 self
  126.         for (SelectionKey key : selector.keys()) {
  127.             //通过 key 取出对应的 SocketChannel
  128.             Channel targetChannel = key.channel();
  129.             //排除自己
  130.             if (targetChannel instanceof SocketChannel && targetChannel != self) {
  131.                 //转型
  132.                 SocketChannel dest = (SocketChannel) targetChannel;
  133.                 //将 msg 存储到 buffer
  134.                 ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
  135.                 //将 buffer 的数据写入通道
  136.                 dest.write(buffer);
  137.             }
  138.         }
  139.     }
  140.  
  141.     public static void main(String[] args) {
  142.         //创建服务器对象
  143.         GroupChatServer groupChatServer = new GroupChatServer();
  144.         groupChatServer.listen();
  145.  
  146.     }
  147. }

运行结果 

客户端命令行：  

                         

 客户端1：

  

客户端2：                                 

客户端3：

 

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

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

  

闽ICP备14008679号