java使用MulticastSocket实现基于广播的多人聊天室

使用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());
  }
}

运行效果

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