使用MulticastSocket实现多点广播(实现多人聊天室)

时间:2022-12-15 11:19:45

使用MulticastSocket实现多点广播:
(1)DatagramSocket只允许数据报发给指定的目标地址,而MulticastSocket可以将数据报以广播的方式发送到多个客户端。
(2)IP协议为多点广播提供了这批特殊的IP地址,这些IP地址的范围是:224.0.0.0至239.255.255.255.
(3)MulticastSocket类时实现多点广播的关键,当MulticastSocket把一个DaragramPocket发送到多点广播的IP地址时,该数据报将会自动广播到加入该地址的所有MulticastSocket。MulticastSocket既可以将数据报发送到多点广播地址,也可以接收其他主机的广播信息。
(4)事实上,MulticastSocket是DatagramSocket的子类,也就是说,MulticastSocket是特殊的DatagramSocket。当要发送一个数据报时,可以使用随机端口创建MulticastSocket,也可以在指定端口创建MulticastSocket。MulticastSocket提供了如下三个构造器:

public MulticastSocket() 使用本机默认地址,随机端口来创建MulticastSocket对象
public MulticastSocket(int portNumber) 用本机默认地址,指定端口来创建MulticastSocket对象
public MulticastSocket(SocketAddress bindaddr) 用指定IP地址,指定端口来创建MulticastSocket对象

(5)创建MulticastSocket对象后,还需要将MulticastSocket加入到指定的多点广播地址。MulticastSocket使用joinGroup()方法加入指定组;使用leaveGroup()方法脱离一个组。

joinGroup(InetAddress multicastAddr) 将该MulticastSocket加入到指定的多点广播地址

leaveGroup(InetAddress multicastAddr) 将该MulticastSocket离开指定的多点广播地址

(6)在某些系统中,可能有多个网络接口,这可能为多点广播带来问题,这时候程序需要在一个指定的网络接口上监听,通过调用setInterface()方法可以强制MulticastSocket使用指定的网络接口‘也可以使用getInterface()方法查询MulticastSocket监听的网络接口。

(7)如果创建仅仅用于发送数据报的MulticastSocket对象,则使用默认地址,随机端口即可。但如果创建接收用的MulticastSocket对象,’则该MulticastSocket对象必须有指定端口,否则无法确定发送数据报的目标端口。

(8)MulticastSocket用于发送接收数据报的方法与DatagramSocket完全一样。但MulticastSocket比DatagramSocket多了一个setTimeToLive(int ttl)方法,该ttl用于设置数据报最多可以跨过多少个网络。
当ttl为0时,指定数据报应停留在本地主机
当ttl为1时,指定数据报发送到本地局域网
当ttl为32时,指定数据报发送到本站点的网络上
当ttl为64时,意味着数据报应该停留在本地区
当ttl为128时,意味着数据报应保留在本大洲
当ttl为255时,意味着数据报可以发送到所有地方
默认情况下,ttl值为1.

程序实例:
下面程序使用MulticastSocket实现一个基于广播的多人聊天室。程序只需要一个MulticastSocket,两个线程,其中MulticastSocket既用于发送,也用于接收;一个线程负责键盘输入,并向MulticastSocket发送数据;一个线程负责从MulticastSocket中读取数据。

package com.talk;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner;
//让该类实现Runnable接口,该类的实例可以作为线程的target
public class MulticastSocketTest implements Runnable{

     //使用常量作为本程序多点广播的IP地址
     private   static  final  String  BROADCAST_IP="230.0.0.1";
     //使用常量作为本程序的多点广播的目的地端口
     public static final  int BROADCAST_PORT=3000;
     //定义每个数据报大小最大为4kb
     private  static final  int  DATA_LEN=4096;
     //定义本程序的MulticastSocket实例
     private  MulticastSocket  socket=null;
     private   InetAddress  broadcastAddress=null;
     private  Scanner  scan=null;

     //定义接收网络数据的字节数组
     byte[]  inBuff=new  byte[DATA_LEN];
     //以指定字节数组创建准备接收数据的MulticastSocket对象
     private  DatagramPacket  inPacket =new  DatagramPacket(inBuff, inBuff.length);

     //定义一个用于发送的DatagramPacket对象
     private DatagramPacket  outPacket=null;

     public void init() throws IOException{
           //创建键盘输入流
           Scanner  scan=new Scanner(System.in);
           //创建用于发送、接收数据的MulticastSocket对象,由于该MulticastSocket需要接收数据,所以有指定端口
           socket=new  MulticastSocket(BROADCAST_PORT);
           broadcastAddress=InetAddress.getByName(BROADCAST_IP);

           //将该socket加入到指定的多点广播地址
           socket.joinGroup(broadcastAddress);
           //设置本MulticastSocket发送的数据报会被回送到自身
           socket.setLoopbackMode(false);

           //初始化发送用的DatagramSocket,它包含一个长度为0的字节数组
           outPacket =new DatagramPacket(new byte[0], 0, broadcastAddress, BROADCAST_PORT);

           //启动本实例的run()方法作为线程执行体的线程
           new  Thread(this).start();

           //不断的读取键盘输入
           while(scan.hasNextLine()){
                //将键盘输入的一行字符转换成字节数组
                byte [] buff=scan.nextLine().getBytes();
                //设置发送用的DatagramPacket里的字节数据
                outPacket.setData(buff);
                //发送数据报
                socket.send(outPacket);
           }
           socket.close();
     }





     public void run() {
           // TODO Auto-generated method stub

           while(true){
                //读取Socket中的数据,读到的数据放入inPacket所封装的字节组里
                try {
                     socket.receive(inPacket);
                     //打印从socket读取到的内容
                     System.out.println("聊天信息:"+new String(inBuff,0,inPacket.getLength()));
                } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                }

                if(socket!=null){
                     //让该socket离开多点IP广播地址
                     try {
                           socket.leaveGroup(broadcastAddress);
                           //关闭socket对象
                           socket.close();
                     } catch (IOException e) {
                           // TODO Auto-generated catch block
                           e.printStackTrace();
                     }

                }

                System.exit(1);
           }
     }
     public static void main(String[] args) {
           try {
                new  MulticastSocketTest().init();
           } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
           }
     }
}

下面将结合MulticastSocket和DatagramSocket开发一个简单的局域网即时通讯工具,局域网内每个用户启动该工具后,就可以看到该局域网内所有的在线用户,该用户也会被其他用户看到:
该程序的思路是:每个用户都启动两个Socket,即MulticastSocket和DatagramSocket。其中MulticastSocket会周期性的向230.0.0.1发送在线信息,且所有的MulticastSocket都会加入到230.0.0.1这个多点广播IP中,这样每个用户都会收到其他用户的在线信息,如果系统在一段时间内没有收到某个用户广播的在线信息,则从用户列表中删除该用户。除此之外,该MulticastSocket还用于向其他用户发送广播信息。

DatagramSocket主要用于发送私聊信息,当用户收到其他用户广播来的DatagramSocket时,即可获得该用户MulticastSocket对应的SocketAddress.这个SocketAddress将作为发送私聊信息的重要依据。—本程序让MulticastSocket在30000端口监听,而DatagramSocket在30001端口监听,这样程序就可以根据其他用户广播来的DatagramPacket得到他的DatagramSocket所在的地址。

本系统提供了一个UserInfo类,该类封装了用户名、图标、对应的SocketAddress以及该用户对应的交谈窗口,失去联系的次数等信息:

package com.talk;
import java.net.SocketAddress;
import com.bank.ChatFrame;
public class UserInfo {
     // 该用户的图标
     private String icon;
     // 该用户的名字
     private String name;
     // 该用户的MulitcastSocket所在的IP和端口
     private SocketAddress address;
     // 该用户失去联系的次数
     private int lost;
     // 该用户对应的交谈窗口
     private ChatFrame chatFrame;
     public UserInfo(){}
     // 有参数的构造器
     public UserInfo(String icon , String name
           , SocketAddress address , int lost)
     {
           this.icon = icon;
           this.name = name;
           this.address = address;
           this.lost = lost;
     }
     // 省略所有成员变量的setter和getter方法
     // icon的setter和getter方法
     public void setIcon(String icon)
     {
           this.icon = icon;
     }
     public String getIcon()
     {
           return this.icon;
     }
     // name的setter和getter方法
     public void setName(String name)
     {
           this.name = name;
     }
     public String getName()
     {
           return this.name;
     }
     // address的setter和getter方法
     public void setAddress(SocketAddress address)
     {
           this.address = address;
     }
     public SocketAddress getAddress()
     {
           return this.address;
     }
     // lost的setter和getter方法
     public void setLost(int lost)
     {
           this.lost = lost;
     }
     public int getLost()
     {
           return this.lost;
     }
     // chatFrame的setter和getter方法
     public void setChatFrame(ChatFrame chatFrame)
     {
           this.chatFrame = chatFrame;
     }
     public ChatFrame getChatFrame()
     {
           return this.chatFrame;
     }
     // 使用address作为该用户的标识,所以根据address作为
     // 重写hashCode()和equals方法的标准
     public int hashCode()
     {
           return address.hashCode();
     }
     public boolean equals(Object obj)
     {
           if (obj != null && obj.getClass() == UserInfo.class)
           {
                UserInfo target = (UserInfo)obj;
                if (address != null)
                {
                     return address.equals(target.getAddress());
                }
           }
           return false;
     }
}

通过UserInfo的封装,所有客户端只需要维护该UserInfo类的列表,程序就可以实现广播、发送私聊信息等功能。本程序的底层通信类则需要一个MulticastSocket和一个DatagramSocket,该工具类的代码如下:

package com.talk;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.SocketAddress;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public class ComUtil {
     // 定义本程序通信所使用的字符集
     public static final String CHARSET = "utf-8";
     // 使用常量作为本程序的多点广播IP地址
     private static final String BROADCAST_IP
           = "230.0.0.1";
     // 使用常量作为本程序的多点广播目的的端口
     // DatagramSocket所用的的端口为该端口+1。
     public static final int BROADCAST_PORT = 30000;
     // 定义每个数据报的最大大小为4K
     private static final int DATA_LEN = 4096;
     // 定义本程序的MulticastSocket实例
     private MulticastSocket socket = null;
     // 定义本程序私聊的Socket实例
     private DatagramSocket singleSocket = null;
     // 定义广播的IP地址
     private InetAddress broadcastAddress = null;
     // 定义接收网络数据的字节数组
     byte[] inBuff = new byte[DATA_LEN];
     // 以指定字节数组创建准备接受数据的DatagramPacket对象
     private DatagramPacket inPacket =
           new DatagramPacket(inBuff , inBuff.length);
     // 定义一个用于发送的DatagramPacket对象
     private DatagramPacket outPacket = null;
     // 聊天的主界面程序
     private LanTalk lanTalk;
     // 构造器,初始化资源
     public ComUtil(LanTalk lanTalk) throws Exception
     {
           this.lanTalk = lanTalk;
           // 创建用于发送、接收数据的MulticastSocket对象
           // 因为该MulticastSocket对象需要接收,所以有指定端口
           socket = new MulticastSocket(BROADCAST_PORT);
           // 创建私聊用的DatagramSocket对象
           singleSocket = new DatagramSocket(BROADCAST_PORT + 1);
           broadcastAddress = InetAddress.getByName(BROADCAST_IP);
           // 将该socket加入指定的多点广播地址
           socket.joinGroup(broadcastAddress);
           // 设置本MulticastSocket发送的数据报被回送到自身
           socket.setLoopbackMode(false);
           // 初始化发送用的DatagramSocket,它包含一个长度为0的字节数组
           outPacket = new DatagramPacket(new byte[0]
                , 0 , broadcastAddress , BROADCAST_PORT);
           // 启动两个读取网络数据的线程
           new ReadBroad().start();
           Thread.sleep(1);
           new ReadSingle().start();
     }
     // 广播消息的工具方法
     public void broadCast(String msg)
     {
           try
           {
                // 将msg字符串转换字节数组
                byte[] buff = msg.getBytes(CHARSET);
                // 设置发送用的DatagramPacket里的字节数据
                outPacket.setData(buff);
                // 发送数据报
                socket.send(outPacket);
           }
           // 捕捉异常
           catch (IOException ex)
           {
                ex.printStackTrace();
                if (socket != null)
                {
                     // 关闭该Socket对象
                     socket.close();
                }
                JOptionPane.showMessageDialog(null
                     , "发送信息异常,请确认30000端口空闲,且网络连接正常!"
                     , "网络异常", JOptionPane.ERROR_MESSAGE);
                System.exit(1);
           }
     }
     // 定义向单独用户发送消息的方法
     public void sendSingle(String msg , SocketAddress dest)
     {
           try
           {
                // 将msg字符串转换字节数组
                byte[] buff = msg.getBytes(CHARSET);
                DatagramPacket packet = new DatagramPacket(buff
                     , buff.length , dest);
                singleSocket.send(packet);
           }
           // 捕捉异常
           catch (IOException ex)
           {
                ex.printStackTrace();
                if (singleSocket != null)
                {
                     // 关闭该Socket对象
                     singleSocket.close();
                }
                JOptionPane.showMessageDialog(null
                     , "发送信息异常,请确认30001端口空闲,且网络连接正常!"
                     , "网络异常", JOptionPane.ERROR_MESSAGE);
                System.exit(1);
           }
     }
     // 不断从DatagramSocket中读取数据的线程
     class ReadSingle extends Thread
     {
           // 定义接收网络数据的字节数组
           byte[] singleBuff = new byte[DATA_LEN];
           private DatagramPacket singlePacket =
                new DatagramPacket(singleBuff , singleBuff.length);
           public void run()
           {
                while (true)
                {
                     try
                     {
                           // 读取Socket中的数据。
                           singleSocket.receive(singlePacket);
                           // 处理读到的信息
                           lanTalk.processMsg(singlePacket , true);
                     }
                     // 捕捉异常
                     catch (IOException ex)
                     {
                           ex.printStackTrace();
                           if (singleSocket != null)
                           {
                                // 关闭该Socket对象
                                singleSocket.close();
                           }
                           JOptionPane.showMessageDialog(null
                                , "接收信息异常,请确认30001端口空闲,且网络连接正常!"
                                , "网络异常", JOptionPane.ERROR_MESSAGE);
                           System.exit(1);
                     }
                }
           }
     }
     // 持续读取MulticastSocket的线程
     class ReadBroad extends Thread
     {
           public void run()
           {
                while (true)
                {
                     try
                     {
                           // 读取Socket中的数据。
                           socket.receive(inPacket);
                           // 打印输出从socket中读取的内容
                           String msg = new String(inBuff , 0
                                , inPacket.getLength() , CHARSET);
                           // 读到的内容是在线信息
                           if (msg.startsWith(YeekuProtocol.PRESENCE)
                                && msg.endsWith(YeekuProtocol.PRESENCE))
                           {
                                String userMsg = msg.substring(2
                                     , msg.length() - 2);
                                String[] userInfo = userMsg.split(YeekuProtocol
                                     .SPLITTER);
                                UserInfo user = new UserInfo(userInfo[1]
                                     , userInfo[0] , inPacket.getSocketAddress(), 0);
                                // 控制是否需要添加该用户的旗标
                                boolean addFlag = true;
                                ArrayList<Integer> delList = new ArrayList<>();
                                // 遍历系统中已有的所有用户,该循环必须循环完成
                                for (int i = 1 ; i < lanTalk.getUserNum() ; i++ )
                                {
                                     UserInfo current = lanTalk.getUser(i);
                                     // 将所有用户失去联系的次数加1
                                     current.setLost(current.getLost() + 1);
                                     // 如果该信息由指定用户发送过来
                                     if (current.equals(user))
                                     {
                                           current.setLost(0);
                                           // 设置该用户无须添加
                                           addFlag = false;
                                     }
                                     if (current.getLost() > 2)
                                     {
                                           delList.add(i);
                                     }
                                }
                                // 删除delList中的所有索引对应的用户
                                for (int i = 0; i < delList.size() ; i++)
                                {
                                     lanTalk.removeUser(delList.get(i));
                                }
                                if (addFlag)
                                {
                                     // 添加新用户
                                     lanTalk.addUser(user);
                                }
                           }
                           // 读到的内容是公聊信息
                           else
                           {
                                // 处理读到的信息
                                lanTalk.processMsg(inPacket , false);
                           }
                     }
                     // 捕捉异常
                     catch (IOException ex)
                     {
                           ex.printStackTrace();
                           if (socket != null)
                           {
                                // 关闭该Socket对象
                                socket.close();
                           }
                           JOptionPane.showMessageDialog(null
                                , "接收信息异常,请确认30000端口空闲,且网络连接正常!"
                                , "网络异常", JOptionPane.ERROR_MESSAGE);
                           System.exit(1);
                     }
                }
           }
     }
}


本程序的一个主类,LanTalk ,该类使用DefaultListModel来维护用户列表,该类里的每个列表项就是一个UserInfo。该类还提供了一个ImageCellRenderer,该类用于将列表项绘制出用户图标和用户名字。

package com.talk;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.net.DatagramPacket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.text.DateFormat;
import java.util.Date;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import com.bank.ChatFrame;
import com.bank.LoginFrame;
public class LanTalk extends JFrame {
     private DefaultListModel<UserInfo> listModel
           = new DefaultListModel<>();
     // 定义一个JList对象
     private JList<UserInfo> friendsList = new JList<>(listModel);
     // 定义一个用于格式化日期的格式器
     private DateFormat formatter = DateFormat.getDateTimeInstance();
     public LanTalk()
     {
           super("局域网聊天");
           // 设置该JList使用ImageCellRenderer作为单元格绘制器
           friendsList.setCellRenderer(new ImageCellRenderer());
           listModel.addElement(new UserInfo("all" , "所有人"
                , null , -2000));
           friendsList.addMouseListener(new ChangeMusicListener());
           add(new JScrollPane(friendsList));
           setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           setBounds(2, 2, 160 , 600);
     }
     // 根据地址来查询用户
     public UserInfo getUserBySocketAddress(SocketAddress address)
     {
           for (int i = 1 ; i < getUserNum() ; i++)
           {
                UserInfo user = getUser(i);
                if (user.getAddress() != null
                     && user.getAddress().equals(address))
                {
                     return user;
                }
           }
           return null;
     }
     // ------下面四个方法是对ListModel的包装------
     // 向用户列表中添加用户
     public void addUser(UserInfo user)
     {
           listModel.addElement(user);
     }
     // 从用户列表中删除用户
     public void removeUser(int pos)
     {
           listModel.removeElementAt(pos);
     }
     // 获取该聊天窗口的用户数量
     public int getUserNum()
     {
           return listModel.size();
     }
     // 获取指定位置的用户
     public UserInfo getUser(int pos)
     {
           return listModel.elementAt(pos);
     }
     // 实现JList上的鼠标双击事件的监听器
     class ChangeMusicListener extends MouseAdapter
     {
           public void mouseClicked(MouseEvent e)
           {
                // 如果鼠标的击键次数大于2
                if (e.getClickCount() >= 2)
                {
                     // 取出鼠标双击时选中的列表项
                     UserInfo user = (UserInfo)friendsList.getSelectedValue();
                     // 如果该列表项对应用户的交谈窗口为null
                     if (user.getChatFrame() == null)
                     {
                           // 为该用户创建一个交谈窗口,并让该用户引用该窗口
                           user.setChatFrame(new ChatFrame(null , user));
                     }
                     // 如果该用户的窗口没有显示,则让该用户的窗口显示出来
                     if (!user.getChatFrame().isShowing())
                     {
                           user.getChatFrame().setVisible(true);
                     }
                }
           }
     }
     /** * 处理网络数据报,该方法将根据聊天信息得到聊天者, * 并将信息显示在聊天对话框中。 * @param packet 需要处理的数据报 * @param single 该信息是否为私聊信息 */
     public void processMsg(DatagramPacket packet , boolean single)
     {
           // 获取该发送该数据报的SocketAddress
           InetSocketAddress srcAddress = (InetSocketAddress)
                packet.getSocketAddress();
           // 如果是私聊信息,则该Packet获取的是DatagramSocket的地址,
           // 将端口减1才是对应的MulticastSocket的地址
           if (single)
           {
                srcAddress = new InetSocketAddress(srcAddress.getHostName()
                     , srcAddress.getPort() - 1);
           }
           UserInfo srcUser = getUserBySocketAddress(srcAddress);
           if (srcUser != null)
           {
                // 确定消息将要显示到哪个用户对应窗口上。
                UserInfo alertUser = single ? srcUser : getUser(0);
                // 如果该用户对应的窗口为空,显示该窗口
                if (alertUser.getChatFrame() == null)
                {
                     alertUser.setChatFrame(new ChatFrame(null , alertUser));
                }
                // 定义添加的提示信息
                String tipMsg = single ? "对您说:" : "对大家说:";
                try{
                     // 显示提示信息
                     alertUser.getChatFrame().addString(srcUser.getName()
                           + tipMsg + "......................("
                           + formatter.format(new Date()) + ")\n"
                           + new String(packet.getData() , 0 , packet.getLength()
                           , ComUtil.CHARSET) + "\n");
                } catch (Exception ex) { ex.printStackTrace(); }
                if (!alertUser.getChatFrame().isShowing())
                {
                     alertUser.getChatFrame().setVisible(true);
                }
           }
     }
     // 主方法,程序的入口
     public static void main(String[] args)
     {
           LanTalk lanTalk = new LanTalk();
           new LoginFrame(lanTalk , "请输入用户名、头像后登录");
     }
}
// 定义用于改变JList列表项外观的类
class ImageCellRenderer extends JPanel
     implements ListCellRenderer<UserInfo>
{
     private ImageIcon icon;
     private String name;
     // 定义绘制单元格时的背景色
     private Color background;
     // 定义绘制单元格时的前景色
     private Color foreground;
     @Override
     public Component getListCellRendererComponent(JList list
           , UserInfo userInfo , int index
           , boolean isSelected , boolean cellHasFocus)
     {
           // 设置图标
           icon = new ImageIcon("ico/" + userInfo.getIcon() + ".gif");
           name = userInfo.getName();
           // 设置背景色、前景色
           background = isSelected ? list.getSelectionBackground()
                : list.getBackground();
           foreground = isSelected ? list.getSelectionForeground()
                : list.getForeground();
           // 返回该JPanel对象作为单元格绘制器
           return this;
     }
     // 重写paintComponent方法,改变JPanel的外观
     public void paintComponent(Graphics g)
     {
           int imageWidth = icon.getImage().getWidth(null);
           int imageHeight = icon.getImage().getHeight(null);
           g.setColor(background);
           g.fillRect(0, 0, getWidth(), getHeight());
           g.setColor(foreground);
           // 绘制好友图标
           g.drawImage(icon.getImage() , getWidth() / 2 - imageWidth / 2
                , 10 , null);
           g.setFont(new Font("SansSerif" , Font.BOLD , 18));
           // 绘制好友用户名
           g.drawString(name, getWidth() / 2 - name.length() * 10
                , imageHeight + 30 );
     }
     // 通过该方法来设置该ImageCellRenderer的最佳大小
     public Dimension getPreferredSize()
     {
           return new Dimension(60, 80);
     }
}
除了以上主要的代码,还有YeekuProtocol   ChatFrame   LoginFrame等类:
package com.talk;
public interface YeekuProtocol {
     String PRESENCE = "⊿⊿";
     String SPLITTER = "▓";
}
package com.bank;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import com.talk.ComUtil;
import com.talk.LanTalk;
import com.talk.YeekuProtocol;
// 登录用的对话框
public class LoginFrame extends JDialog {
     public JLabel tip;
     public JTextField userField = new JTextField("钱钟书" , 20);
     public JComboBox<Integer> iconList = new JComboBox<>(
           new Integer[]{1, 2, 3, 4, 5 , 6, 7, 8 ,9 ,10});
     private JButton loginBn = new JButton("登录");
     // 聊天的主界面
     private LanTalk chatFrame;
     // 聊天通信的工具实例
     public static ComUtil comUtil;
     // 构造器,用于初始化的登录对话框
     public LoginFrame(LanTalk parent , String msg)
     {
           super(parent , "输入名字后登录" , true);
           this.chatFrame = parent;
           setLayout(new GridLayout(5, 1));
           JPanel jp = new JPanel();
           tip = new JLabel(msg);
           tip.setFont(new Font("Serif" , Font.BOLD , 16));
           jp.add(tip);
           add(jp);
           add(getPanel("用户名" , userField));
           iconList.setPreferredSize(new Dimension(224, 20));
           add(getPanel("图 标" , iconList));
           JPanel bp = new JPanel();
           loginBn.addActionListener(new MyActionListener(this));
           bp.add(loginBn);
           add(bp);
           pack();
           setVisible(true);
     }
     // 工具方法,该方法将一个字符串和组件组合成JPanel对象
     private JPanel getPanel(String name , JComponent jf)
     {
           JPanel jp = new JPanel();
           jp.add(new JLabel(name + ":"));
           jp.add(jf);
           return jp;
     }
     // 该方法用于改变登录窗口最上面的提示信息
     public void setTipMsg(String tip)
     {
           this.tip.setText(tip);
     }
     // 定义一个事件监听器
     class MyActionListener implements ActionListener
     {
           private LoginFrame loginFrame;
           public MyActionListener(LoginFrame loginFrame)
           {
                this.loginFrame = loginFrame;
           }
           // 当鼠标单击事件发生时
           public void actionPerformed(ActionEvent evt)
           {
                try
                {
                     // 初始化聊天通信类
                     comUtil = new ComUtil(chatFrame);
                     final String loginMsg = YeekuProtocol.PRESENCE + userField.getText()
                           + YeekuProtocol.SPLITTER + iconList.getSelectedObjects()[0]
                           + YeekuProtocol.PRESENCE;
                     comUtil.broadCast(loginMsg);
                     // 启动定时器每20秒广播一次在线信息
                     javax.swing.Timer timer = new javax.swing.Timer(1000 * 10
                           , event-> comUtil.broadCast(loginMsg));
                     timer.start();
                     loginFrame.setVisible(false);
                     chatFrame.setVisible(true);
                }
                catch (Exception ex)
                {
                     loginFrame.setTipMsg("确认30001端口空闲,且网络正常!");
                }
           }
     }
}

package com.bank;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.net.InetSocketAddress;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import com.talk.LanTalk;
import com.talk.UserInfo;
// 定义交谈的对话框
public class ChatFrame extends JDialog
{
     // 聊天信息区
     JTextArea msgArea = new JTextArea(12 , 45);
     // 聊天输入区
     JTextField chatField = new JTextField(30);
     // 发送聊天信息的按钮
     JButton sendBn = new JButton("发送");
     // 该交谈窗口对应的用户
     UserInfo user;
     // 构造器,用于初始化交谈对话框的界面
     public ChatFrame(LanTalk parent , final UserInfo user)
     {
           super(parent , "和" + user.getName() + "聊天中" , false);
           this.user = user;
           msgArea.setEditable(false);
           add(new JScrollPane(msgArea));
           JPanel buttom = new JPanel();
           buttom.add(new JLabel("输入信息:"));
           buttom.add(chatField);
           buttom.add(sendBn);
           add(buttom , BorderLayout.SOUTH);
           // 发送消息的Action,Action是ActionListener的子接口
           Action sendAction = new AbstractAction()
           {
                @Override
                public void actionPerformed(ActionEvent evt)
                {
                     InetSocketAddress dest = (InetSocketAddress)user.getAddress();
                     // 在聊友列表中,所有人项的SocketAddress是null
                     // 这表明是向所有人发送消息
                     if (dest == null)
                     {
                          LoginFrame.comUtil.broadCast(chatField.getText());
                           msgArea.setText("您对大家说:"
                                + chatField.getText() + "\n" + msgArea.getText());
                     }
                     // 向私人发送信息
                     else
                     {
                           // 获取发送消息的目的
                           dest = new InetSocketAddress(dest.getHostName(),
                                dest.getPort() + 1);
                          LoginFrame.comUtil.sendSingle(chatField.getText(), dest);
                           msgArea.setText("您对" + user.getName() +  "说:"
                                + chatField.getText() + "\n" + msgArea.getText());
                     }
                     chatField.setText("");
                }
           };
           sendBn.addActionListener(sendAction);
           // 将Ctrl+Enter键和"send"关联
          chatField.getInputMap().put(KeyStroke.getKeyStroke('\n'
                , java.awt.event.InputEvent.CTRL_MASK) , "send");
           // 将"send"与sendAction关联
           chatField.getActionMap().put("send", sendAction);
           pack();
     }
     // 定义向聊天区域添加消息的方法
     public void addString(String msg)
     {
           msgArea.setText(msg + "\n" + msgArea.getText());
     }
}

运行效果
使用MulticastSocket实现多点广播(实现多人聊天室)