促进 Java 中的高可用性集群 (HAC)

Question

对于我的课堂项目，我有以下问题。我能够接收客户信息并将信息重新发送给相应的客户。但是，我无法将每个客户的信息发送给每个其他客户（广播？）。我还需要实现给定的功能。任何帮助，将不胜感激。

目标是设计和实现一个基于 UDP 的简单应用层协议，以 促进高可用性集群 (HAC)。 HAC 有一套机制来检测故障转移， 网络/节点故障等，以便将流量重新路由到可用系统。在这个项目中 您将不会处理诸如如何执行一致的故障转移或高 可用性分布式管理程序。但是，您的任务是设计和实现一个协议 维护整个集群的上行节点信息。 您设计的协议应执行以下功能：

a) 定期检测节点故障

b) 通知网络中的其他节点有关故障（对等选项）

c) 能够检测故障节点何时恢复运行

d) 通知其他节点新节点的可用性

客户端类：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.*;
import java.util.Random;

public class UDPClient 
{
    DatagramSocket Socket;

    public UDPClient() 
    {

    }

    public void createAndListenSocket() throws ClassNotFoundException, InterruptedException 
    {
        try 
        {
            Socket = new DatagramSocket();
            InetAddress IPAddress = InetAddress.getByName("localhost");
            byte[] incomingData = new byte[1024];
            String sentence = "Client 1 is up";
            byte[] data = sentence.getBytes();
            boolean flag = true; 
            CreatePacket packet = new CreatePacket(data, flag, data.length);

         while(true)
         {            
            //Serialize to send          
             Random rnd = new Random();
             int timeout = rnd.nextInt(30);
             Thread.sleep(timeout*1000); 

            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(buffer);
            out.writeObject(packet);
            out.close();
            buffer.close();

            DatagramPacket sendPacket = new DatagramPacket(buffer.toByteArray(), buffer.size(), IPAddress, 9876);
            Socket.send(sendPacket);
            System.out.println("Message sent from client");           

            //Deserialize and receive packet from server
            DatagramPacket incomingPacket = new DatagramPacket(incomingData, incomingData.length);
            Socket.receive(incomingPacket);

            ByteArrayInputStream bis = new ByteArrayInputStream(incomingPacket.getData());
            ObjectInputStream in = new ObjectInputStream(bis);
            Object receivedPacket = in.readObject();
            in.close();

            InetAddress IPAddress1 = incomingPacket.getAddress();
            int port = incomingPacket.getPort();

            System.out.println();
            System.out.println("Response from server: ");
            System.out.println("Message : " + receivedPacket.toString());
            System.out.println("Client IP: "+ IPAddress1.getHostAddress());
            System.out.println("Client port: "+ port);                       
         }           
        }
        catch (UnknownHostException e) 
        {
            e.printStackTrace();
        } 
        catch (SocketException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception 
    {
        UDPClient client = new UDPClient();
        client.createAndListenSocket(); 
    }
}

服务器代码：

public class UDPServer 
{
    DatagramSocket socket = null;

    public UDPServer() 
    {

    }
    public void createAndListenSocket() throws ClassNotFoundException 
    {
        try 
        {
            socket = new DatagramSocket(9876);
            byte[] incomingData = new byte[1024];

            while (true) 
            {

                DatagramPacket incomingPacket = new DatagramPacket(incomingData, incomingData.length);
                socket.receive(incomingPacket);
                CreatePacket toSendPacket = new CreatePacket(incomingData, incomingData.length);
                ArrayList <CreatePacket> clients = new ArrayList<CreatePacket>(4);

               ByteArrayInputStream bis = new ByteArrayInputStream(incomingPacket.getData());
               ObjectInputStream in = new ObjectInputStream(bis);
               Object receivedPacket = in.readObject();
               in.close();

               clients.add(toSendPacket); 

               InetAddress IPAddress = incomingPacket.getAddress();
               int port = incomingPacket.getPort();

               System.out.println(); 
               System.out.println("" + receivedPacket.toString());
               System.out.println("Client IP: "+ IPAddress.getHostAddress());
               System.out.println("Client port: "+ port);

               DatagramPacket replyPacket = new DatagramPacket(incomingData, incomingData.length, IPAddress, port);
               Thread.sleep(10*1000);
                socket.send(replyPacket);
                //socket.close();
            }
        } 
        catch (SocketException e) 
        {
            e.printStackTrace();
        } 
        catch (IOException i) 
        {
            i.printStackTrace();
        } 
        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws ClassNotFoundException, IOException 
    {
        UDPServer server = new UDPServer();
        server.createAndListenSocket();
    }
}

Answer 1

你想要 1 - 客户端发送消息到服务器，如果它是 up/alive 2 - 如果服务器接收到信号，它会向所有客户端发送一些消息吗？

我不确定，但你可以试试这个， InetAddress IPAddress = incomingPacket.getAddress(); int port = incomingPacket.getPort(); 当您获得一个客户端的 IP 地址时，您可以将服务器端所有客户端的地址存储在列表或数组中。然后，如果您收到信号到服务器，请使用该列表发送响应。 您将需要根据 up/alive 客户端更新列表。