java使用MulticastSocket实现基于广播的多人聊天室
这篇文章主要为大家详细介绍了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;
//以指定字节数组创建准备接收数据的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, 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;
// 以指定字节数组创建准备接受数据的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 , 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;
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
, userinfo , 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()
+ 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());
}
}
运行效果
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持CodeAE代码之家。
原文链接：https://blog.csdn.net/zlz18225318697/article/details/52607528
http://www.zzvips.com/article/173891.html
页:
[1]