正文
java即时消息源代码 java如何实现实时消息推送
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java 即时消息提醒
//原代码需要编译
package com.imti.chatdemo;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.util.Date;
/**
*简易网络聊天类
*@1.0版 2009年2月21日
*@author liangzhuoxun
*/
public class Chat extends JFrame implements ActionListener,Runnable
{
JPanel pane1,pane2;//声明面板
JLabel label,label2,label3;//声明标签
JTextField tfield1,tfield2,tfield3;//声明文本框
JTextArea tarea;//声明文本域
JScrollPane scroll;//声明带滚动条java即时消息源代码的文本域
JButton button,buttont;//声明按钮
String str1,str2,info,s;
Thread thread;
DatagramPacket dp1,dp2;
DatagramSocket ds1,ds2;
/**
*构造方法
*/
public Chat()
{
super("简易聊天工具-作者:liangzhuoxun");
//文本域
tarea=new JTextArea(15,47);
scroll=new JScrollPane(tarea,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
//标签 文本框面板
pane1=new JPanel();//初始化面板
label=new JLabel("聊天内容:");
tfield1=new JTextField(25);
button=new JButton("发送");
buttont=new JButton("清空聊天内容");
button.addActionListener(this);//添加事件处理器
buttont.addActionListener(this);
tfield1.addKeyListener(
/**
*该匿名类是继承键盘适配器重写按键方法达到将文本框内容输入文本域
*/
new KeyAdapter()
{
public void keyPressed(KeyEvent kevent)
{
str1=new String(tfield1.getText());
if(kevent.getKeyCode()==KeyEvent.VK_ENTER)//判断回车键
{
Integer i=new Integer(tfield3.getText());
try
{
sends();//发送方法
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
}
);
pane1.add(label);//面板中添加标签
pane1.add(tfield1);//面板中添加文本框
pane1.add(button);//添加按钮
pane1.add(buttont);
pane2=new JPanel();
tfield2=new JTextField("127.0.0.1",15);
tfield3=new JTextField("5000",5);
label2=new JLabel("输入发送java即时消息源代码的目的地:");
label3=new JLabel(" 端口号:");
pane2.add(label2);
pane2.add(tfield2);
pane2.add(label3);
pane2.add(tfield3);
this.add(pane2,"North"); //设置窗口布局
this.add(scroll,"Center");//窗口中添加带滚动条文本域
this.add(pane1,"South");//窗口中添加面板
this.setBounds(100,150,550,400);//设置窗口位置和大小
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭按钮方式
this.show(); //窗口可视
Thread thread=new Thread(this);
thread.start();
}
/**
*实现按钮发送的方法
*/
public void actionPerformed(ActionEvent event)
{
str2=new String(event.getActionCommand());
if(str2.equals("发送"))
{
try
{
sends();//发送方法
}
catch(Exception e)
{
e.printStackTrace();
}
}else if(str2.equals("清空聊天内容"))
{
Toolkit.getDefaultToolkit().beep();//调用"滴"声音
tarea.setText("");
JOptionPane.showMessageDialog(null,"清空完成!!!");//对话框
}
}
/**
*发送信息的方法
*/
public void sends() throws Exception
{
str1=new String(tfield1.getText());
Integer i=new Integer(tfield3.getText());
ds1=new DatagramSocket();
dp1=new DatagramPacket(str1.getBytes(),(str1.getBytes()).length,
InetAddress.getByName(tfield2.getText()),i);
ds1.send(dp1);
ds1.close();
int len=(tarea.getText()).length();//求出文本域里已有内容长度
Date time=new Date();
//将发送内容放置文本域里
tarea.insert("\r\n\n发至:"+dp1.getAddress().getHostAddress()+" 时间:"+
time.toLocaleString()+"\n"+tfield1.getText()+"\n",len);//将文本框中内容插入指定位置
tfield1.setText(""); //清空文本框
}
/**
*实现Runnable接口的run方法
*/
public void run()
{
while(true)
{
try
{
Thread.currentThread().sleep(600);//线程暂停0.6秒
s=Receives();
if(s.length()0)
{
tarea.setText(tarea.getText()+"\n"+s);
}
}catch(Exception ie)
{
ie.printStackTrace();
}
}
}
//接收信息的方法
public String Receives() throws Exception
{
ds2=new DatagramSocket(5000);
byte[] buf=new byte[1024];
dp2=new DatagramPacket(buf,1024);
ds2.receive(dp2);
String s="来自:"+dp2.getAddress()+" 时间:"+new Date().toLocaleString()
+"\n"+new String(dp2.getData(),0,dp2.getLength());
ds2.close();
return s;
}
/**
*主函数
*/
public static void main(String[] args)
{
Chat c=new Chat();
}
}
//这是java的原代码 拿过去编译下就可以用java即时消息源代码了
相关问答
Q1: 如何用JAVA实现Linux上的消息队列功能
下面来说说如何用不用消息队列来进行进程间的通信，消息队列与命名管道有很多相似之处。有关命名管道的更多内容可以参阅我的另一篇文章：Linux进程间通信——使用命名管道
一、什么是消息队列
消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型，接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是消息队列与命名管道一样，每个数据块都有一个最大长度的限制。
Linux用宏MSGMAX和MSGMNB来限制一条消息的最大长度和一个队列的最大长度。
二、在Linux中使用消息队列
Linux提供了一系列消息队列的函数接口来让我们方便地使用它来实现进程间的通信。它的用法与其他两个System V PIC机制，即信号量和共享内存相似。
1、msgget函数
该函数用来创建和访问一个消息队列。它的原型为：
int msgget(key_t, key, int msgflg);
与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。
它返回一个以key命名的消息队列的标识符（非零整数），失败时返回-1.
2、msgsnd函数
该函数用来把消息添加到消息队列中。它的原型为：
int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);
msgid是由msgget函数返回的消息队列标识符。
msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：
struct my_message{
long int message_type;
/* The data you wish to transfer*/
};
msg_sz是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。
如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.
3、msgrcv函数
该函数用来从一个消息队列获取消息，它的原型为
int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);
msgid, msg_ptr, msg_st的作用也函数msgsnd函数的一样。
msgtype可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1.
4、msgctl函数
该函数用来控制消息队列，它与共享内存的shmctl函数相似，它的原型为：
int msgctl(int msgid, int command, struct msgid_ds *buf);
command是将要采取的动作，它可以取3个值，
IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
IPC_RMID：删除消息队列
buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：
struct msgid_ds
{
uid_t shm_perm.uid;
uid_t shm_perm.gid;
mode_t shm_perm.mode;
};
成功时返回0，失败时返回-1.
三、使用消息队列进行进程间通信
马不停蹄，介绍完消息队列的定义和可使用的接口之后，我们来看看它是怎么让进程进行通信的。由于可以让不相关的进程进行行通信，所以我们在这里将会编写两个程序，msgreceive和msgsned来表示接收和发送信息。根据正常的情况，我们允许两个程序都可以创建消息，但只有接收者在接收完最后一个消息之后，它才把它删除。
接收信息的程序源文件为msgreceive.c的源代码为：
#include unistd.h
#include stdlib.h
#include stdio.h
#include string.h
#include errno.h
#include sys/msg.h
struct msg_st
{
long int msg_type;
char text[BUFSIZ];
};
int main()
{
int running = 1;
int msgid = -1;
struct msg_st data;
long int msgtype = 0; //注意1
//建立消息队列
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(EXIT_FAILURE);
}
//从队列中获取消息，直到遇到end消息为止
while(running)
{
if(msgrcv(msgid, (void*)data, BUFSIZ, msgtype, 0) == -1)
{
fprintf(stderr, "msgrcv failed with errno: %d\n", errno);
exit(EXIT_FAILURE);
}
printf("You wrote: %s\n",data.text);
//遇到end结束
if(strncmp(data.text, "end", 3) == 0)
running = 0;
}
//删除消息队列
if(msgctl(msgid, IPC_RMID, 0) == -1)
{
fprintf(stderr, "msgctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
发送信息的程序的源文件msgsend.c的源代码为：
#include unistd.h
#include stdlib.h
#include stdio.h
#include string.h
#include sys/msg.h
#include errno.h
#define MAX_TEXT 512
struct msg_st
{
long int msg_type;
char text[MAX_TEXT];
};
int main()
{
int running = 1;
struct msg_st data;
char buffer[BUFSIZ];
int msgid = -1;
//建立消息队列
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(EXIT_FAILURE);
}
//向消息队列中写消息，直到写入end
while(running)
{
//输入数据
printf("Enter some text: ");
fgets(buffer, BUFSIZ, stdin);
data.msg_type = 1; //注意2
strcpy(data.text, buffer);
//向队列发送数据
if(msgsnd(msgid, (void*)data, MAX_TEXT, 0) == -1)
{
fprintf(stderr, "msgsnd failed\n");
exit(EXIT_FAILURE);
}
//输入end结束输入
if(strncmp(buffer, "end", 3) == 0)
running = 0;
sleep(1);
}
exit(EXIT_SUCCESS);
}
转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦
Q2: 关于Java聊天收到消息自动弹出窗口代码
tcp或者udp设置为全局的，不要定义在某一个窗体里面，当udp读取线程接受到数据后，就直接new这个窗体，把消息带过去，比如new ChatFrame(String msg).show();就行了。
Q3: java实现聊天室是怎么做到的？
Java 实现聊天室可以分为以下几个步骤：
建立服务器端
首先需要建立一个服务器端，负责接收客户端的连接请求并处理客户端发送过来的消息。
建立客户端
然后需要建立客户端，客户端通过网络连接到服务器端，并向服务器端发送消息。
实现通信协议
为了实现聊天室功能，需要定义一个通信协议，规定客户端和服务器端之间的通信格式，例如消息的头部和内容等。
实现多线程处理
聊天室通常会有多个用户同时在线，因此需要使用多线程来处理多个客户端的连接请求和消息传递。
实现GUI界面（可选）
为了方便用户使用，可以实现一个GUI界面，让用户可以方便地发送和接收消息。
以下是一个简单的 Java 聊天室的代码示例：
java
Copy code
// 服务器端代码
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
Socket socket = serverSocket.accept();
new Thread(new ServerThread(socket)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThread implements Runnable {
private Socket socket;
private BufferedReader reader;
private PrintWriter writer;
public ServerThread(Socket socket) {
this.socket = socket;
try {
reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
writer = new PrintWriter(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
public void run() {
try {
String msg;
while ((msg = reader.readLine()) != null) {
// 处理客户端发送过来的消息
System.out.println("接收到消息：" + msg);
// 将消息发送给所有客户端
for (Socket s : ServerThreadList.getList()) {
if (s != socket) {
PrintWriter w = new PrintWriter(s.getOutputStream());
w.println(msg);
w.flush();
}
}
}
// 关闭连接
socket.close();
ServerThreadList.removeThread(this);
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThreadList {
private static List
list = new ArrayList();
public static void addThread(ServerThread thread) {
list.add(thread);
}
public static void removeThread(ServerThread thread) {
list.remove(thread);
}
public static List
getList() {
return list;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 8888);
new Thread(new ClientThread(socket)).start();
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
PrintWriter writer = new PrintWriter(socket.getOutputStream());
while (true) {
String msg = reader.readLine();
writer.println(msg);
writer.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientThread implements Runnable {
private Socket socket;
private BufferedReader reader;
public ClientThread(Socket socket) {
this.socket = socket;
try {
reader
Q4: 如何使用java实现两台计算机的通信 源代码
一个简单java即时消息源代码的聊天程序
参考一下java即时消息源代码；
//客户端java即时消息源代码的
import java.io.*;
import java.net.*;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class ChatClient {
public static void main(String[] args) {
ChatClient cc=new ChatClient();
cc.receive();
}
JTextField jtf;
JTextArea jta;
Socket s;
PrintWriter out;
BufferedReader in;
public ChatClient(){
JFrame frame=new JFrame("ChatClient");
frame.setSize(400,300);
jta=new JTextArea();
jta.setEditable(false);
jtf=new JTextField();
jtf.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
send();
}
});
frame.getContentPane().add(new JScrollPane(jta));
frame.getContentPane().add(jtf,"South");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
try {
s=new Socket("127.0.0.1",9000);
in=new BufferedReader(new InputStreamReader(s.getInputStream()));
out=new PrintWriter(s.getOutputStream());
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void receive(){
while(true){
try {
String text=in.readLine();
this.jta.append(text+"\n");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return;
}
}
}
public void send(){
String text=this.jtf.getText();
this.jtf.setText("");
out.println(text);
out.flush();
}
}
//服务器端java即时消息源代码的
import java.net.*;
import java.io.*;
import java.util.*;
public class ChatServer {
public static void main(String[] args) throws Exception {
ServerSocket ss=new ServerSocket(9000);
List list=new ArrayList();
while(true){
Socket s=ss.accept();
list.add(s);
Thread t=new ServerThread(s,list);
t.start();
}
}
}
class ServerThread extends Thread{
Socket s;
List list;
BufferedReader in;
PrintWriter out;
public ServerThread(Socket s, List list) {
this.s = s;
this.list = list;
try {
in=new BufferedReader(new InputStreamReader(s.getInputStream()));
out=new PrintWriter(s.getOutputStream());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void run(){
while(true){
try {
String str=in.readLine();
if (str==null) return;
Iterator it=list.iterator();
while(it.hasNext()){
Socket socket=(Socket)(it.next());
PrintWriter o=new PrintWriter(socket.getOutputStream());
o.println(str);
o.flush();
}
} catch (IOException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
return;
}
}
}
}
java即时消息源代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java如何实现实时消息推送、java即时消息源代码的信息别忘了在本站进行查找喔。
