JAVA UDP:客户端未从服务器接收回复

当这些类在同一台计算机上时，它们可以成功地进行通信。但是，一旦我们将“天线”移动到另一台计算机上（仍然在同一网络上），服务器仍然会收到包，但客户端只是一直在等待回复

我们已经检查了这个站点的som和其他线程，但仍然找不到问题。有人能帮忙吗

服务器接收器类：

 package Server;

    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.InetSocketAddress;
    import java.net.UnknownHostException;
    import java.sql.Timestamp;
    import java.util.Vector;

    public class RecieverProxy extends Thread {
    private DatagramSocket socket;
    private static int length;
    private String reqS;

    public static java.util.Date date = new java.util.Date();
    public static Timestamp currentTimestamp = new Timestamp(date.getTime());

    @Override
    public void run() {
        try {
            System.out.println(currentTimestamp + "  Server[IP=\""
                    + InetAddress.getLocalHost().getHostAddress()
                    + "\"]: Local server is Running...");
            System.out.println(currentTimestamp
                    + "  SERVER: Connecting to MySQL server...");
            DbUpdater.readyDatabase();
            System.out.println(currentTimestamp
                    + "  SERVER: MySQL server is connected!");

        } catch (UnknownHostException e) {
            e.printStackTrace();
            System.exit(1);
        }
        System.err.println(currentTimestamp + "  SERVER: Ready... waiting...");
        try {
            recieveSendUDP();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * The method will wait for a request, process the request, and then return
     * the reply.
     * 
     * @throws InterruptedException
     */
    public boolean recieveSendUDP() throws IOException, InterruptedException {
        socket = new DatagramSocket(6789);

        // modtag forespørgsler
        while (true) {
            try {
                byte[] bytes = new byte[1000];
                DatagramPacket request = new DatagramPacket(bytes, bytes.length);
                socket.receive(request);
                length = request.getLength();

                String replyS = "ERROR";

                String oldreqS = new String(request.getData());

                if (oldreqS == "[]") {
                    System.out.println(currentTimestamp
                            + "  None bluetooth devices nearby");
                    replyS = "None bluetooth devices nearby";
                } else {
                    String subreqS = oldreqS.substring(0, length);
                    String leftreqS = subreqS.replace("[", "'");
                    String rightreqS = leftreqS.replace("]", "'");
                    reqS = rightreqS.replaceAll(", ", "','");
                    replyS = currentTimestamp
                            + "  SERVER: MAC addresses recieved.";
                }

                // gør svar klar
                int dstPort = request.getPort();
                InetAddress dstAdr = request.getAddress();
                System.out.println(currentTimestamp
                        + "  SERVER: Sending reply to IP: " + dstAdr.toString()
                        + " på port " + dstPort);

                DatagramSocket replySocket = new DatagramSocket();
                replySocket.send(new DatagramPacket(replyS.getBytes(), replyS
                        .getBytes().length, new InetSocketAddress(dstAdr,
                        dstPort)));
                replySocket.close();
                DbUpdater.dbUpdate(reqS);
            } catch (Exception e) {
            }

        }
    }
}

天线发送器类别：

package Antenna;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.sql.Timestamp;
import java.util.Vector;

public class SendRemoteDevices {

    public static java.util.Date date = new java.util.Date();
    public static Timestamp currentTimestamp = new Timestamp(date.getTime());

    public static void runMacSender() throws IOException, InterruptedException {

        Vector<String> macAdds;

        macAdds = RemoteDeviceDiscovery.getMacVec();
        System.out.println(currentTimestamp
                + "  ANTENNA: Sending macaddresses: " + macAdds);
        sendMacc(macAdds);
    }

    public static void sendMacc(Vector<String> macAdd) {
        String request = new Vector<String>(macAdd).toString().trim();
        String reply = sendReceive(request);
    }

    // send string and receive string
    // her skal serverens addresse stå
    @SuppressWarnings("resource")
    public static String sendReceive(String request) {
        String ip = "192.168.10.106";
        String serverIP = ip; // sæt anden IP ind hvis du kører
                                // mellem
                                // to maskiner
        DatagramSocket ds = null;
        byte[] bytes = request.getBytes(); // husk : er seperator

        // sending package after encrypting.
        try {
            ds = new DatagramSocket();
            ds.send(new DatagramPacket(bytes, bytes.length,
                    new InetSocketAddress(serverIP, 6789)));
            System.out.println(currentTimestamp
                    + "  ANTENNA: Send this to serveren: \"" + request + "\"");
            System.out.println(currentTimestamp
                    + "  ANTENNA: Waiting for answer from Server...");
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // gør mig klar til at modtage
        byte[] repBytes = new byte[1000];
        DatagramPacket repGram = new DatagramPacket(repBytes, repBytes.length);
        try {
            ds.receive(repGram);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } // receive

        // trim er nødvendigt
        String reply = new String(repGram.getData()).trim();
        System.out.println(currentTimestamp
                + "  ANTENNA: Reply from Server: \"" + reply + "\"");
        try { // fordi den ikke printer ovenstående før menuen
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return reply;
    }
}

封装天线；
导入java.io.IOException；
导入java.net.DatagramPacket；
导入java.net.DatagramSocket；
导入java.net.InetAddress；
导入java.net.InetSocketAddress；
导入java.net.SocketException；
导入java.net.UnknownHostException；
导入java.sql.Timestamp；
导入java.util.Vector；
公共类SendRemoteDevices{
public static java.util.Date Date=new java.util.Date（）；
公共静态时间戳currentTimestamp=新时间戳（date.getTime（））；
public static void runMacSender（）引发IOException、InterruptedException{
向量macads；
macAdds=RemoteDeviceDiscovery.getMacVec（）；
System.out.println（当前时间戳
+“天线：发送macAdds:”+macAdds）；
sendMacc（macads）；
}
公共静态无效sendMacc（向量macAdd）{
字符串请求=新向量（macAdd）.toString（）.trim（）；
字符串reply=sendReceive（请求）；
}
//发送字符串和接收字符串
//她的skal Servens致辞是stå
@抑制警告（“资源”）
公共静态字符串sendReceive（字符串请求）{
字符串ip=“192.168.10.106”；
字符串serverIP=ip；//sæt anden ip ind hvis du kører
//梅勒姆
//马斯基纳
DatagramSocket ds=null；
byte[]bytes=request.getBytes（）；//外壳：er分隔符
//加密后发送包。
试一试{
ds=新的DatagramSocket（）；
ds.send（新数据包）（字节，字节.length，
新的InetSocketAddress（serverIP，6789））；
System.out.println（当前时间戳
+“天线：将此发送到服务器：\”“+请求+\”）；
System.out.println（当前时间戳
+“天线：等待服务器的应答…”）；
}捕获（SocketException e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
//gør mig klar直到modtage
字节[]repBytes=新字节[1000]；
DatagramPacket repGram=新的DatagramPacket（repBytes，repBytes.length）；
试一试{
ds.接收（repGram）；
}捕获（SocketException e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}//接收
//修剪器nødvendigt
字符串回复=新字符串（repGram.getData（））.trim（）；
System.out.println（当前时间戳
+“天线：来自服务器的回复：\”“+回复+”\”）；
试试看{//fordi den ikke打印机Ovendeående før menuen
睡眠（100）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
回复；
}
}

您的

ds.receive（）

正在侦听哪个IP和端口？确定。。我现在尝试在这行中定义端口：ds=newdatagramsocket（80）；这让它一度奏效。所以天线可以发送和接收，但只能发送和接收一次。你可以发送和接收任意次数。是的，但它在一次成功（发送和接收）后崩溃。异常表示连接已经被绑定并引用以下行：ds=newdatagramsocket（80）；在使用它之后，不幸的是，我无法复制该异常。不管我现在做什么，天线只是在等待回复。