Java中的群组聊天应用程序-yiteyi-C++库

本文讨论了一个使用MulticastSocket（Java平台SE 7）类的群组聊天应用程序。MulticastSocket是一个（UDP）DatagramSocket，具有加入internet上其他多播主机的“组”的附加功能。

null

实施

                     import                               java.net.*;                   
                     import                               java.io.*;                   
                     import                               java.util.*;                   
                     public                               class                               GroupChat                   
                     {                   
                                         private                               static                               final                               String TERMINATE =                               "Exit"                               ;                   
                                         static                               String name;                   
                                         static                               volatile                               boolean                               finished =                               false                               ;                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         if                               (args.length !=                               2                               )                   
                                         System.out.println(                               "Two arguments required: <multicast-host> <port-number>"                               );                   
                                         else                   
                                         {                   
                                         try                   
                                         {                   
                                         InetAddress group = InetAddress.getByName(args[                               0                               ]);                   
                                         int                               port = Integer.parseInt(args[                               1                               ]);                   
                                         Scanner sc =                               new                               Scanner(System.in);                   
                                         System.out.print(                               "Enter your name: "                               );                   
                                         name = sc.nextLine();                   
                                         MulticastSocket socket =                               new                               MulticastSocket(port);                   
                             
                                         // Since we are deploying                   
                                         socket.setTimeToLive(                               0                               );                   
                                         //this on localhost only (For a subnet set it as 1)                   
                             
                                         socket.joinGroup(group);                   
                                         Thread t =                               new                               Thread(                               new                   
                                         ReadThread(socket,group,port));                   
                             
                                         // Spawn a thread for reading messages                   
                                         t.start();                   
                             
                                         // sent to the current group                   
                                         System.out.println(                               "Start typing messages..."                               );                   
                                         while                               (                               true                               )                   
                                         {                   
                                         String message;                   
                                         message = sc.nextLine();                   
                                         if                               (message.equalsIgnoreCase(GroupChat.TERMINATE))                   
                                         {                   
                                         finished =                               true                               ;                   
                                         socket.leaveGroup(group);                   
                                         socket.close();                   
                                         break                               ;                   
                                         }                   
                                         message = name +                               ": "                               + message;                   
                                         byte                               [] buffer = message.getBytes();                   
                                         DatagramPacket datagram =                               new                   
                                         DatagramPacket(buffer,buffer.length,group,port);                   
                                         socket.send(datagram);                   
                                         }                   
                                         }                   
                                         catch                               (SocketException se)                   
                                         {                   
                                         System.out.println(                               "Error creating socket"                               );                   
                                         se.printStackTrace();                   
                                         }                   
                                         catch                               (IOException ie)                   
                                         {                   
                                         System.out.println(                               "Error reading/writing from/to socket"                               );                   
                                         ie.printStackTrace();                   
                                         }                   
                                         }                   
                                         }                   
                     }                   
                     class                               ReadThread                               implements                               Runnable                   
                     {                   
                                         private                               MulticastSocket socket;                   
                                         private                               InetAddress group;                   
                                         private                               int                               port;                   
                                         private                               static                               final                               int                               MAX_LEN =                               1000                               ;                   
                                         ReadThread(MulticastSocket socket,InetAddress group,                               int                               port)                   
                                         {                   
                                         this                               .socket = socket;                   
                                         this                               .group = group;                   
                                         this                               .port = port;                   
                                         }                   
                             
                                         @Override                   
                                         public                               void                               run()                   
                                         {                   
                                         while                               (!GroupChat.finished)                   
                                         {                   
                                         byte                               [] buffer =                               new                               byte                               [ReadThread.MAX_LEN];                   
                                         DatagramPacket datagram =                               new                   
                                         DatagramPacket(buffer,buffer.length,group,port);                   
                                         String message;                   
                                         try                   
                                         {                   
                                         socket.receive(datagram);                   
                                         message =                               new                   
                                         String(buffer,                               0                               ,datagram.getLength(),                               "UTF-8"                               );                   
                                         if                               (!message.startsWith(GroupChat.name))                   
                                         System.out.println(message);                   
                                         }                   
                                         catch                               (IOException e)                   
                                         {                   
                                         System.out.println(                               "Socket closed!"                               );                   
                                         }                   
                                         }                   
                                         }                   
                     }                   

将文件另存为GroupChat。java并使用javac进行编译，然后使用指定的两个命令行参数运行程序。多播主机由D类IP地址和标准UDP端口号指定。D类IP地址的范围为224.0.0.0至239.255.255.255（含）。地址224.0.0.0是保留的，不应使用。以下是上述程序的示例输出：

我们使用多播主机IP地址为239.0.0.0，端口号为1234（因为端口号0到1023是保留的）。该小组有三名成员：铁人、美国队长和格罗特。在发送消息之前，首先启动所有三个终端，否则在启动终端之前发送的消息将丢失（因为没有合并缓冲区来存储消息的设施）这个应用程序需要两个线程。一个用于接受用户输入（使用java.util.Scanner类），另一个用于读取从其他客户端发送的消息。因此，我将执行阅读工作的线程分离为ReadThreadclass。要离开组，任何用户都可以输入Exit来终止会话。

上述程序在一台机器上执行。Socket编程用于分布式编程。当同一段代码片段出现在安装了Java的不同机器上时，可以满足这一要求。这只是简单的服务逻辑。如果开发前端，该项目将更加吸引人。您可以使用Java的AWT（抽象窗口工具包）或其高级对应工具Java Swing来开发前端。既然这不是Socket编程的一部分，我就不讨论细节了。 其他要点：

您可以通过在通过网络发送消息之前执行加密来整合网络安全功能。
可以使用凯撒密码等原始技术或RSA等高级方法来执行加密解密。您可以尝试使用Java的RMI（远程方法调用）来执行相同的任务。
在这里，您可以最大限度地利用Java提供的抽象。然而，如果您的主要目标是效率，那么套接字编程是最佳选择。因为它不需要任何运行时支持，所以它比RMI快一点。

本文由再见 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java