JavaFx中UDP通信的编码

我在JavaFx中编码UDP通信时遇到问题

代码能够发送消息，但不能接收消息

我应该在源代码中修改什么来接收消息

以下是源代码：

public class JavaFXApplication10 extends Application {

public DatagramSocket receivesocket; 
public DatagramPacket receivepacket; 
public DatagramSocket sendsocket;    
public DatagramPacket sendpacket;   
public InetSocketAddress remoteAdress;

public Label     label_IP;
public TextField tx_IP;
public Label     label_SENDPORT;
public Label     label_RECEIVEPORT;
public TextField tx_SENDPORT;
public TextField tx_RECEIVEPORT;
public Button    bt_co;
public Button    bt_start ;
private String    message; 
private XYChart.Series series; 
private Timeline timer; 
private static String    IP = "192.168.121.23"; 
private static Integer SENDPORT = 12345;       
private static Integer RECEIVEPORT = 12345;    
public double time_counter=0.0;
private String text;
private byte[] b;
@Override

public void start(Stage stage) throws Exception{


    /* text */
     tx_IP = TextFieldBuilder.create().text(IP).build();

    /* text */
    tx_SENDPORT = TextFieldBuilder.create().text(""+SENDPORT).build();

    /* text */
    tx_RECEIVEPORT = TextFieldBuilder.create().text(""+RECEIVEPORT).build();

    /*button */
    bt_co = ButtonBuilder.create().text("Connection")
            .prefWidth(200)
            .alignment(Pos.CENTER)
            .id("connect")
            .build();

    /* button_start */
    bt_start = ButtonBuilder.create().text("START")
            .id("start")
            .build();


    /* timer */
     timer = new Timeline(new KeyFrame(Duration.millis(1000), new EventHandler<ActionEvent>(){
        @Override
        public void handle(ActionEvent event) {

           time_counter = time_counter+1; // time

        }
    }));
    timer.setCycleCount(Timeline.INDEFINITE);
    timer.play();

    /*figure*/
    stage.setTitle("Line Chart Sample");

    final NumberAxis xAxis = new NumberAxis();
    final NumberAxis yAxis = new NumberAxis();
    xAxis.setLabel("Time [s]");
    yAxis.setLabel("Force [N]");
    //creating the chart
    final LineChart<Number,Number> lineChart = 
            new LineChart<Number,Number>(xAxis,yAxis);

    lineChart.setTitle("");

    //defining a series
    series = new XYChart.Series();
    series.setName("Force");
    series.getData().add(new XYChart.Data(0.0,0.0));
     lineChart.getData().add(series);




    HBox root1 = HBoxBuilder.create().spacing(100).children(tx_IP ,tx_SENDPORT,tx_RECEIVEPORT).build();
    HBox root2 = HBoxBuilder.create().spacing(50).children(bt_co).build();
    HBox root3 = HBoxBuilder.create().spacing(25).children(bt_start).build();
    VBox root4 = VBoxBuilder.create().spacing(25).children(root1,root2,root3,lineChart).build();


    Scene scene = new Scene(root4);

    recieve_UDP();


    scene.addEventHandler(ActionEvent.ACTION,actionHandler);



    stage = StageBuilder.create().width(640).height(640).scene(scene).title(" ").build();
    stage.show(); 
}


private void recieve_UDP() throws SocketException, IOException {


    ScheduledService<Boolean> ss = new ScheduledService<Boolean>()
    {
        @Override
        protected Task<Boolean> createTask()
        {

            Task<Boolean> task = new Task<Boolean>()
            {
                @Override
                protected Boolean call() throws Exception
                {
                  receivesocket = null;

                   byte[] receiveBuffer = new byte[1024];
                   receivepacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
                   receivesocket = new DatagramSocket(RECEIVEPORT);


                   receivesocket.receive(receivepacket);
                   message = new String(receivepacket.getData(),0, receivepacket.getLength());

                   System.out.println(message);



                   receivesocket.close();
                  return true;
                };
            };


             return task;           
        }

    };
    ss.start();
}



EventHandler<ActionEvent> actionHandler = new EventHandler<ActionEvent>(){
    public void handle (ActionEvent e){


        //////////////////////////////////////////////////////////////////////////////  
        Button src =(Button)e.getTarget();
        text = src.getId(); 
        System.out.println(text);
        b = new byte[5];

        if(text == "connect"){

          String text_IP = tx_IP.getText(); 

          label_IP.setText(text_IP);

          IP = text_IP; 


          String text_SENDPORT = tx_SENDPORT.getText(); 


          label_SENDPORT.setText(text_SENDPORT);

          SENDPORT = Integer.parseInt( text_SENDPORT);

          String text_RECEIVEPORT = tx_RECEIVEPORT.getText(); 

          label_RECEIVEPORT.setText(text_RECEIVEPORT);

          RECEIVEPORT = Integer.parseInt(text_RECEIVEPORT);

        }
        else{


               remoteAdress = new InetSocketAddress(IP, SENDPORT);

       sendsocket = null;


               try {
                   sendsocket = new DatagramSocket();
               } catch (SocketException ex) {
                  Logger.getLogger(JavaFXApplication10.class.getName()).log(Level.SEVERE, null, ex);
               }

               }
               if(text=="start"){

                     b[0] = (byte)0x02;
                     text ="OK";   


               }

               else{

               }


        Send_UDP();
         /////////////////////////////////////////////////////// 
    }
};
public void Send_UDP(){

    /////////////////////////////////////////////////////// 
if(text=="OK"){

            sendpacket = new DatagramPacket(b, b.length,remoteAdress);

            try {

                sendsocket.send(sendpacket);
            } catch (IOException ex) {
                Logger.getLogger(JavaFXApplication10.class.getName()).log(Level.SEVERE, null, ex);
            }

            sendsocket.close();
            text="";

            }
        else {}
        /////////////////////////////////////////////////////// 

}


public static void main(String[] args) {
    launch(args);
}
}

公共类JavaFXApplication10扩展应用程序{
公共数据采集器接收插座；
公共数据包接收包；
公共DatagramSocket sendsocket；
公共数据包发送包；
公共InetSocketAddress远程地址；
公共标签；
公共文本字段tx_IP；
公共标签发送端口；
公共标签接收端口；
公共文本字段tx_发送端口；
公共文本字段tx_RECEIVEPORT；
公共按钮bt_公司；
公共按钮bt_启动；
私有字符串消息；
私有XYChart.系列；
私人时间计时器；
私有静态字符串IP=“192.168.121.23”；
私有静态整数发送端口=12345；
私有静态整数RECEIVEPORT=12345；
公共双时间计数器=0.0；
私有字符串文本；
专用字节[]b；
@凌驾
public void start（Stage）引发异常{
/*正文*/
tx_IP=TextFieldBuilder.create（）.text（IP.build（）；
/*正文*/
tx_SENDPORT=TextFieldBuilder.create（）.text（“+SENDPORT.build（）”；
/*正文*/
tx_RECEIVEPORT=TextFieldBuilder.create（）.text（“+RECEIVEPORT.build（）”；
/*钮扣*/
bt_co=ButtonBuilder.create（）.text（“连接”）
.宽度（200）
.校准（位置中心）
.id（“连接”）
.build（）；
/*启动按钮*/
bt_start=ButtonBuilder.create（）.text（“开始”）
.id（“开始”）
.build（）；
/*计时器*/
计时器=新的时间线（新的关键帧（Duration.millis（1000），新的EventHandler（）{
@凌驾
公共无效句柄（ActionEvent事件）{
时间计数器=时间计数器+1；//时间
}
}));
timer.setCycleCount（Timeline.unfinite）；
timer.play（）；
/*身材*/
阶段。设置标题（“折线图样本”）；
最终数字axis xAxis=新数字axis（）；
最终数字axis yAxis=新数字axis（）；
xAxis.setLabel（“时间]”；
yAxis.setLabel（“强制[N]”）；
//创建图表
最终线形图线形图=
新的线形图（xAxis、yAxis）；
线形图。设置标题（“”）；
//定义系列
series=新的XYChart.series（）；
series.setName（“Force”）；
series.getData（）.add（新的XYChart.Data（0.0,0.0））；
lineChart.getData（）.add（系列）；
HBox root1=HBoxBuilder.create（）.间距（100）.子项（tx_IP，tx_SENDPORT，tx_RECEIVEPORT）.build（）；
hboxroot2=HBoxBuilder.create（）.spating（50）.children（bt_co.build（）；
hboxroot3=HBoxBuilder.create（）.spating（25）.children（bt_start）.build（）；
VBox root4=VBoxBuilder.create（）.间距（25）.子项（root1，root2，root3，lineChart）.build（）；
场景=新场景（root4）；
接收UDP（）；
scene.addEventHandler（ActionEvent.ACTION，actionHandler）；
stage=StageBuilder.create（）.width（640）.height（640）.scene（scene）.title（“”.build（）；
stage.show（）；
}
私有void receive_UDP（）抛出SocketException，IOException{
ScheduledService ss=新的ScheduledService（）
{
@凌驾
受保护的任务createTask（）
{
任务=新任务（）
{
@凌驾
受保护的布尔调用（）引发异常
{
receivesocket=null；
字节[]接收缓冲区=新字节[1024]；
receivepacket=新数据包（receiveBuffer，receiveBuffer.length）；
receivesocket=新的DatagramSocket（RECEIVEPORT）；
receivesocket.receive（receivepacket）；
message=新字符串（receivepacket.getData（），0，receivepacket.getLength（））；
System.out.println（消息）；
receivesocket.close（）；
返回true；
};
};
返回任务；
}
};
ss.start（）；
}
EventHandler actionHandler=新的EventHandler（）{
公共无效句柄（ActionEvent e）{
//////////////////////////////////////////////////////////////////////////////  
按钮src=（按钮）e.getTarget（）；
text=src.getId（）；
System.out.println（文本）；
b=新字节[5]；
如果（文本==“连接”）{
字符串text_IP=tx_IP.getText（）；
label_IP.setText（text_IP）；
IP=文本_IP；
字符串text_SENDPORT=tx_SENDPORT.getText（）；
label_SENDPORT.setText（text_SENDPORT）；
SENDPORT=Integer.parseInt（text\u SENDPORT）；
字符串text_RECEIVEPORT=tx_RECEIVEPORT.getText（）；
label_RECEIVEPORT.setText（text_RECEIVEPORT）；
RECEIVEPORT=Integer.parseInt（text\u RECEIVEPORT）；
}
否则{
RemoteAddress=新的InetSocketAddress（IP，发送端口）；
sendsocket=null；
试一试{
sendsocket=newdatagramsocket（）；
}捕获（SocketException例外）{
Logger.getLogger（JavaFXApplication10.class.getName（））.log（Level.SEVERE，null，ex）；
}
}
如果（文本==“开始”）{
b[0]=（字节）0x02；
text=“确定”；
}
否则{
}
发送UDP（）；
/////////////////////////////////////////////////////// 
}
};
公共无效发送_UDP（）{
/////////////////////////////////////////////////////// 
如果（文本=“确定”）{
sendpacket=新数据包（b，b.长度，远程地址）；
试一试{
sendsocket.send（sendpacket）；
}捕获（IOEX异常）{
Logger.getLogger（JavaFXApplication10.class.getName（））.log（Level.SEVERE，null，ex）；
}
sendsocket.close（）；
text=“”；
}
else{}
/////////////////////////////////////////////////
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Date;

public class SimpleUDPClient {
    public static void main(String[] args) throws IOException {

        // get a datagram socket
        DatagramSocket socket = new DatagramSocket();
        System.out.println("### socket.getLocalPort():" + socket.getLocalPort() + " | socket.getPort(): " + socket.getPort());

        // send request
        byte[] buf = "Hello, I am UDP client".getBytes();
        InetAddress address = InetAddress.getByName("localhost");
        DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 8002);
        socket.send(packet);

        // get response
        packet = new DatagramPacket(buf, buf.length);
        System.out.println("Waiting to receive response from server." + new Date());
        socket.receive(packet);
        System.out.println("Got the response back from server." + new Date());

        // display response
        String received = new String(packet.getData());
        System.out.println("Quote of the Moment: " + received);

        socket.close();
    }
}

import java.io.*;
import java.net.*;
import java.util.*;

public class SimpleUDPServer {

    public static void main(String[] args) throws SocketException, InterruptedException {
        DatagramSocket socket = new DatagramSocket(8002);

        while (true) {
            try {
                byte[] buf = new byte[256];

                // receive request
                DatagramPacket packet = new DatagramPacket(buf, buf.length);
                socket.receive(packet);

                System.out.println("### socket.getLocalPort():" + socket.getLocalPort() + " | socket.getPort(): " + socket.getPort());

                // figure out response
                String dString = "Server is responding:  asd  asdd";
                buf = new byte[256];
                buf = dString.getBytes();

                // send the response to the client at "address" and "port"
                InetAddress address = packet.getAddress();
                int port = packet.getPort();
                System.out.println("Data from client: " + new String(packet.getData()));
                packet = new DatagramPacket(dString.getBytes(), dString.getBytes().length, address, port);
                System.out.println("### Sending for packet.hashCode(): " + packet.hashCode() + " | packet.getPort(): " + packet.getPort());

                //Thread.sleep(5000);

                System.out.println("Now sending the response back to UDP client.");

                DatagramSocket sendingDatagramSocket = new DatagramSocket();
                sendingDatagramSocket.send(packet);
                sendingDatagramSocket.close();
                System.out.println("I am done");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}