Java 通过套接字发送字符串。服务器没有接收到它_Java_String_Sockets_Serversocket

Java 通过套接字发送字符串。服务器没有接收到它

java string sockets

Java 通过套接字发送字符串。服务器没有接收到它,java,string,sockets,serversocket,Java,String,Sockets,Serversocket,我最近一直在努力寻找通过套接字文件传递字符串的方法。我计划创建一个远程工具（客户端），根据收到的消息（服务器）执行操作。我在谷歌上搜索了我的问题的答案，我找到了一些东西，并设法理解了一些东西，但我也遇到了一些问题（我是编程新手，还没有上大学）在这件事上，如果有任何帮助，我将不胜感激 SocketService.java----类文件=服务器端 package socket; import java.io.DataInputStream; import java.io.EOFExcepti

我最近一直在努力寻找通过套接字文件传递字符串的方法。我计划创建一个远程工具（客户端），根据收到的消息（服务器）执行操作。我在谷歌上搜索了我的问题的答案，我找到了一些东西，并设法理解了一些东西，但我也遇到了一些问题（我是编程新手，还没有上大学）

在这件事上，如果有任何帮助，我将不胜感激

SocketService.java----类文件=服务器端

 package socket;

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.TimeUnit;

public class ServiceSocket {
    static ServerSocket myService;
    static Socket thesocket;
    static Thread socketThread;
    public static boolean socketRunning;
     public static DataInputStream socketMessage;


    public static void initialise(String localhost, int portNumber ){
        // make a server socket//////
        try {
            myService = new ServerSocket(portNumber);
            System.out.println();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //////////////////////////////

    }

    public static void deploySocket(){
        socketThread = new Thread() {
            public void run(){

                // making connection
                System.out.println("VVaiting for connection...");
                try {
                    thesocket = myService.accept();
                    System.out.println("Connection made");
                    socketRunning = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                ////////////////////////////////////
                try {
                    StartBrain();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }

                if(socketRunning = false) {
                try {
                    thesocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
      }

    };
        socketThread.start();
  }

     public static String getSocketMessage() throws IOException {

         try {
            socketMessage = new DataInputStream(thesocket.getInputStream());
        } catch (IOException e1) {
            e1.printStackTrace();
        }
         boolean looprunning = true;
         String message = null;
         System.out.println("entering loop");
               do {
                   try {
                   while (socketMessage.readUTF() != null) {

                message = socketMessage.readUTF();
                looprunning = false;
                      }
                   } catch (EOFException e) {

                   }
               }while(looprunning);

                System.out.println("Message received from UTF: " + message);
                System.out.println("loop exited vvith message");   

         if(message == null) {
          message = "no message";
         }

         return message;
     }

     public static void StartBrain() throws IOException {
         System.out.println("socket brain started");
        String BrainMessage = getSocketMessage();
             if(BrainMessage == "command") {
                 System.out.println("Command EXECUTED HAHA");
             } else if(BrainMessage == "taskschedule") {
                 System.out.println("task scheduled");
             } else {
                 System.out.println("no command received");
             }

         }

Main.java-----类文件=服务器端主包装

import socket.ServiceSocket;

public class Main {

   public static void main(String[] args) {

      ServiceSocket.initialise("localhost", 3535);
      ServiceSocket.deploySocket();
    }
   }  
}

Main.java=客户端

package mainPackage;

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

public class Main {
    private static Socket clientSocket;

    public static void sendMessage(String message) throws IOException, InterruptedException {
        DataOutputStream dOut = new DataOutputStream(Main.clientSocket.getOutputStream());

        dOut.writeUTF(message);
        dOut.flush(); 

        dOut.close();
            }

    public static void main(String[] args) throws Exception {
     //   String modifiedSentence;

        clientSocket = new Socket("localhost", 3535);
        System.out.println("Initializing");
        sendMessage("command");

        boolean running = true;
     while(running) {
         TimeUnit.SECONDS.sleep(3);
         sendMessage("taskschedule");
     }
     clientSocket.close();

    }
}

主要问题

 do {
                   try {
                   while (socketMessage.readUTF() != null) {

                message = socketMessage.readUTF();
                looprunning = false;
                      }
                   } catch (EOFException e) {

                   }
               }while(looprunning);

它不读取字符串/UTF

而是读取它，如下所示：

while (socketMessage.readUTF() != null) {

然后丢弃它，因为您没有将返回值赋给变量，然后尝试读取另一个变量，如下所示：

message = socketMessage.readUTF();

但是您发送的第一条消息已经不见了。

它确实读到了，这里：

while (socketMessage.readUTF() != null) {

然后丢弃它，因为您没有将返回值赋给变量，然后尝试读取另一个变量，如下所示：

message = socketMessage.readUTF();

但是您发送的第一条消息已经不见了。

您的电子邮件有问题

while (socketMessage.readUTF() != null) {
    message = socketMessage.readUTF();
    looprunning = false;
}

第一次调用方法

readUTF（）

将阻止线程并从套接字读取UTF字符串，但您将放弃此值，然后再次尝试读取字符串

如果替换

socketMessage.readUTF（）！=空

且

循环运行

服务器将记录此消息：

VVaiting for connection...
Connection made
socket brain started
entering loop
Message received from UTF: command
loop exited vvith message
no command received

附言。无法识别该命令，因为使用带有

==

的比较对象（字符串是对象），但必须使用

等于
public static void StartBrain() throws IOException {
    System.out.println("socket brain started");
    String BrainMessage = getSocketMessage();
    if (BrainMessage.equals("command")) {
        System.out.println("Command EXECUTED HAHA");
    } else if (BrainMessage.equals("taskschedule")) {
        System.out.println("task scheduled");
    } else {
        System.out.println("no command received");
    }

}

服务器日志：
VVaiting for connection...
Connection made
socket brain started
entering loop
Message received from UTF: command
loop exited vvith message
Command EXECUTED HAHA

你有问题吗
while (socketMessage.readUTF() != null) {
    message = socketMessage.readUTF();
    looprunning = false;
}

第一次调用方法readUTF（）
将阻止线程并从套接字读取UTF字符串，但您将放弃此值，然后再次尝试读取字符串
如果替换socketMessage.readUTF（）！=空
且循环运行
服务器将记录此消息：
VVaiting for connection...
Connection made
socket brain started
entering loop
Message received from UTF: command
loop exited vvith message
no command received

附言。
无法识别该命令，因为使用带有==
的比较对象（字符串是对象），但必须使用等于
public static void StartBrain() throws IOException {
    System.out.println("socket brain started");
    String BrainMessage = getSocketMessage();
    if (BrainMessage.equals("command")) {
        System.out.println("Command EXECUTED HAHA");
    } else if (BrainMessage.equals("taskschedule")) {
        System.out.println("task scheduled");
    } else {
        System.out.println("no command received");
    }

}

服务器日志：
VVaiting for connection...
Connection made
socket brain started
entering loop
Message received from UTF: command
loop exited vvith message
Command EXECUTED HAHA

为什么要从readUTF（）
测试null作为返回值？你为什么把它当作终止条件？它永远不会返回null，更不用说作为终止哨兵了，但它会在流的末尾抛出EOFException
。为什么要将null作为readUTF（）的返回值进行测试？你为什么把它当作终止条件？它永远不会返回null，更不用说作为终止哨兵，但它会在流的末尾抛出EOFException
。