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

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 addhttp://ress , 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 delList = new ArrayList<>();

// 遍历系统中已有的所有用户,该循环必须循环完成

for (int i = 1 ; i < lanTalk.getUserNum() ; i++ )

{

UserInfo current = lanTalk.getUser(i);

// 将所有用户失去联系的次数加1

current.setLost(current.getLost() + 1);

// 如果该信息由指定用户发送过来

if (currOaXeODAent.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 listModel

= new DefaultListModel<>();

// 定义一个JList对象

private JList 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

{

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 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.geOaXeODAtName() + "说："

+ 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());

}

运行效果

Flask接口签名sign原理与实例代码浅析

271 2023-01-15

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

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

java中的接口是类吗

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！