Java 套接字 Json

已更新

响应后有我更新的代码，我有一个问题，现在我没有收到任何东西:

问题:

Connexion cliente reçue.
Lancement du traitement de la connexion cliente
Exception in thread "Thread-1" java.lang.NullPointerException
    at cuisine.TimeServer.onResponseReceived(TimeServer.java:85)
    at cuisine.ClientProcessor.run(ClientProcessor.java:43)
    at java.base/java.lang.Thread.run(Thread.java:844)

时间服务器:85:回调

  @Override
  public void onResponseReceived(String response) {
    // When the response is received from ClientProcessor
    // this method is called (by ClientProcessor).
    // Your response is the parameter String response.
    callback.onResponse(response);
  }

客户端处理器:43:

server.onResponseReceived(response);

一个客户端可以连接，但我无法接收任何内容:Json 或文本。

这是我的新 Java 代码:

Main.java:

   import cuisine.TimeServer.OnResponseReceivedListener;


public class main implements OnResponseReceivedListener {

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

        String host = "192.168.1.21";
        int port = 8080;

        TimeServer ts = new TimeServer(host, port);
        ts.open();
        System.out.println("------------Connected ! ------------");

   }

   @Override
   public void onResponse(String response) {
     doSomethingWith(response);
     System.out.println("REPONSE : ");
     System.out.println(response);

   }

   private void doSomethingWith(String response) {
         System.out.println("REPONSE : ");
         System.out.println(response);
   }


}

我现在真的不知道如何使用响应，因为系统输出“RESPONSE”不在我的控制台中 TimeServer.java:

...
import cuisine.ClientProcessor.Server;


public class TimeServer implements Server {

  public interface OnResponseReceivedListener {
    void onResponse(String response);
  }

  private int port = 2345;
  private String host = "127.0.0.1";
  private ServerSocket server = null;
  private boolean isRunning = true;
  private OnResponseReceivedListener callback;

  public TimeServer() {
    try {
      server = new ServerSocket(port, 100, InetAddress.getByName(host));
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public TimeServer(String pHost, int pPort) {
    host = pHost;
    port = pPort;
    try {
      server = new ServerSocket(port, 100, InetAddress.getByName(host));
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void open() {

    Thread t =
        new Thread(
            new Runnable() {
              public void run() {
                while (isRunning == true) {

                  try {
                    Socket client = server.accept();

                    System.out.println("Connexion cliente reçue.");
                    ClientProcessor c = new ClientProcessor(client);
                    Thread t = new Thread(c);
                    // Don't forget to define the Server for ClientProcessor
                    c.addServer(TimeServer.this);
                    t.start();

                  } catch (IOException e) {
                    e.printStackTrace();
                  }
                }

                try {
                  server.close();
                } catch (IOException e) {
                  e.printStackTrace();
                  server = null;
                }
              }
            });

    t.start();
  }

  @Override
  public void onResponseReceived(String response) {
    // When the response is received from ClientProcessor
    // this method is called (by ClientProcessor).
    // Your response is the parameter String response.
    callback.onResponse(response);
  }

  public void addOnResponseReceivedListener(OnResponseReceivedListener listener) {
    callback = listener;
  }

  public void removeOnResponseReceivedListener() {
    callback = null;
  }

  public void close() {
    isRunning = false;
  }
}

ClientProcessor.java:

public class ClientProcessor implements Runnable {

      public interface Server {
        void onResponseReceived(String response);
      }

      private Socket sock;
      private PrintWriter writer = null;
      private BufferedInputStream reader = null;
      public List<Dish> dish;
      // Your server instance
      private Server server;

      public ClientProcessor(Socket pSock) {
        this.sock = pSock;
      }

      public void run() {
        System.err.println("Lancement du traitement de la connexion cliente");

        boolean closeConnexion = false;
        while (!sock.isClosed()) {

          try {

            writer = new PrintWriter(sock.getOutputStream());
            reader = new BufferedInputStream(sock.getInputStream());

            String response = read();

            // report the response to TimeServer
            server.onResponseReceived(response);

            InetSocketAddress remote = (InetSocketAddress) sock.getRemoteSocketAddress();

            String debug = "";
            debug = "Thread : " + Thread.currentThread().getName() + ". ";
            debug += "Demande de l'adresse : " + remote.getAddress().getHostAddress() + ".";
            debug += " Sur le port : " + remote.getPort() + ".\n";
            debug += "\t -> Commande reçue : " + response + "\n";
            System.err.println("\n" + debug);

            String toSend = "";

            switch (response.toUpperCase()) {
              case "ORDER":
                toSend = "Dish";
                break;
              case "CLOSE":
                toSend = "Communication terminée";
                closeConnexion = true;
                break;
              default:
                toSend = "Commande inconnu !";
                break;
            }

            writer.write(toSend);
            writer.flush();

            if (closeConnexion) {
              System.err.println("COMMANDE CLOSE DETECTEE ! ");
              writer = null;
              reader = null;
              sock.close();
              break;
            }
          } catch (SocketException e) {
            System.err.println("LA CONNEXION A ETE INTERROMPUE ! ");
            break;
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
      }

      public void addServer(Server server) {
        this.server = server;
      }

      private void removeServer() {
        server = null;
      }

      // La méthode que nous utilisons pour lire les réponses
      private String read() throws IOException {
        String response = "";
        int stream;
        byte[] b = new byte[4096];
        stream = reader.read(b);
        response = new String(b, 0, stream);
        return response;
      }
    }

谢谢，本杰明。

最佳答案

更新(更新了Main.java)

更新 No2(从 Main.java 中删除静态方法并使用 Main 对象)

编辑:(删除了之前有关套接字的答案)

This is the json response, now i want to use it in my main : on another class in the same package.

既然您已经声明您正在从客户端获得响应，但您不知道如何在您的Main类中操作它，那么您的问题不在于套接字。

解决方案:使用回调:

ClientProcessor 将向 TimeServer 报告响应。
TimeServer 会将该响应报告给 Main。

使 ClientProcessor 了解服务器并在获取响应时报告。

public class ClientProcessor implements Runnable {

  public interface Server {
    void onResponseReceived(String response);
  }

  private Socket sock;
  private PrintWriter writer = null;
  private BufferedInputStream reader = null;
  public List<Dish> dish;
  // Your server instance
  private Server server;

  public ClientProcessor(Socket pSock) {
    this.sock = pSock;
  }

  public void run() {
    System.err.println("Lancement du traitement de la connexion cliente");

    boolean closeConnexion = false;
    while (!sock.isClosed()) {

      try {

        writer = new PrintWriter(sock.getOutputStream());
        reader = new BufferedInputStream(sock.getInputStream());

        String response = read();

        // report the response to TimeServer
        server.onResponseReceived(response);

        InetSocketAddress remote = (InetSocketAddress) sock.getRemoteSocketAddress();

        String debug = "";
        debug = "Thread : " + Thread.currentThread().getName() + ". ";
        debug += "Demande de l'adresse : " + remote.getAddress().getHostAddress() + ".";
        debug += " Sur le port : " + remote.getPort() + ".\n";
        debug += "\t -> Commande reçue : " + response + "\n";
        System.err.println("\n" + debug);

        String toSend = "";

        switch (response.toUpperCase()) {
          case "ORDER":
            toSend = "Dish";
            break;
          case "CLOSE":
            toSend = "Communication terminée";
            closeConnexion = true;
            break;
          default:
            toSend = "Commande inconnu !";
            break;
        }

        writer.write(toSend);
        writer.flush();

        if (closeConnexion) {
          System.err.println("COMMANDE CLOSE DETECTEE ! ");
          writer = null;
          reader = null;
          sock.close();
          break;
        }
      } catch (SocketException e) {
        System.err.println("LA CONNEXION A ETE INTERROMPUE ! ");
        break;
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

  private void addServer(Server server) {
    this.server = server;
  }

  private void removeServer() {
    server = null;
  }

  // La méthode que nous utilisons pour lire les réponses
  private String read() throws IOException {
    String response = "";
    int stream;
    byte[] b = new byte[4096];
    stream = reader.read(b);
    response = new String(b, 0, stream);
    return response;
  }
}

现在转到TimeServer并使其了解Main(与之前的过程相同)。当从 ClientProcessor 收到响应时，您还必须向 Main 报告响应。

public class TimeServer implements Server {

  public interface OnResponseReceivedListener {
    void onResponse(String response);
  }

  private int port = 2345;
  private String host = "127.0.0.1";
  private ServerSocket server = null;
  private boolean isRunning = true;
  private OnResponseReceivedListener callback;

  public TimeServer() {
    try {
      server = new ServerSocket(port, 100, InetAddress.getByName(host));
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public TimeServer(String pHost, int pPort) {
    host = pHost;
    port = pPort;
    try {
      server = new ServerSocket(port, 100, InetAddress.getByName(host));
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void open() {

    Thread t =
        new Thread(
            new Runnable() {
              public void run() {
                while (isRunning == true) {

                  try {
                    Socket client = server.accept();

                    System.out.println("Connexion cliente reçue.");
                    Thread t = new Thread(new ClientProcessor(client));
                    // Don't forget to define the Server for ClientProcessor
                    t.addServer(TimeServer.this);
                    t.start();

                  } catch (IOException e) {
                    e.printStackTrace();
                  }
                }

                try {
                  server.close();
                } catch (IOException e) {
                  e.printStackTrace();
                  server = null;
                }
              }
            });

    t.start();
  }

  @Override
  public void onResponseReceived(String response) {
    // When the response is received from ClientProcessor
    // this method is called (by ClientProcessor).
    // Your response is the parameter String response.
    callback.onResponse(response);
  }

  public void addOnResponseReceivedListener(OnResponseReceivedListener listener) {
    callback = listener;
  }

  public void removeOnResponseReceivedListener() {
    callback = null;
  }

  public void close() {
    isRunning = false;
  }
}

最后，让您的 Main 监听 TimeServer 并在收到响应时执行某些操作。

public class Main implements OnResponseReceivedListener {

  public static void main(String[] args) {
    Main application = new Main();
    TimeServer ts = application.createTimeServer();
    ts.addOnResponseReceivedListener(application);
    ts.open();
    System.out.println("------------Connected ! ------------");
  }

  @Override
  public void onResponse(String response) {
    doSomethingWith(response);
  }

  private void doSomethingWith(String response) {
    // Your logic for the response here...
  }

  private TimeServer createTimeServer() {
    String host = "192.168.43.178";
    int port = 8080;
    return new TimeServer(host, port);
  }
}

关于Java 套接字 Json，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53781709/

上一篇：java - 从 ivy 本地存储库中删除的 Ant 任务

下一篇：java - 具有 JDBC 访问功能的 Oracle 11g 远程测试实例