Question

我有一个Java应用程序正在检查文件系统是否有更改 - 创建，删除和修改文件和文件夹。它正在向PHP应用程序发送消息。所以这是Java应用程序正在运行的情况，我正在指定的目录中创建一个新文件。 Java正在捕获它并在控制台上显示它（用于测试目的），然后它将它发送到PHP。当我刷新时，我看到了消息，但是如果我不刷新页面并在指定目录中创建新文件，Java就不会在控制台中显示消息，也不会将其发送到PHP。因此，似乎基本上在文件夹中的每次更改后我都要刷新以捕获更改。我想知道我是否可以使用AJAX来避免每次更改后刷新。如果AJAX不是一个选项，或者它将无法正常工作还有其他方法吗？这是我的代码：

主要

package com.company;

import java.io.IOException;
import java.nio.file.*;

import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_DELETE;
import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;

public class Main {

    public static final String DIRECTORY_TO_WATCH = "D:/Test";

    public static void main(String[] args) throws IOException, InterruptedException {
    // write your code here
        Path toWatch = Paths.get(DIRECTORY_TO_WATCH);
        CommunicationServer server = CommunicationServer.getInstance();
        if(toWatch == null) {
            throw new UnsupportedOperationException("Directory not found");
        }

        // make a new watch service that we can register interest in
        // directories and files with.
        WatchService myWatcher = toWatch.getFileSystem().newWatchService();
       // CommunicationServer server = new CommunicationServer();

        // start the file watcher thread below
        MyWatchQueueReader fileWatcher = new MyWatchQueueReader(myWatcher, server);
        Thread th = new Thread(fileWatcher, "FileWatcher");
        th.start();

        // register a file
        toWatch.register(myWatcher, ENTRY_CREATE, ENTRY_MODIFY);
        th.join();
    }
}

阅读器

package com.company;

import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;

/**
 * Created by Ivan on 3/16/2016.
 */
public class MyWatchQueueReader implements Runnable {

    /** the watchService that is passed in from above */
    private WatchService myWatcher;
   private CommunicationServer server;
    public MyWatchQueueReader(WatchService myWatcher, CommunicationServer server) {
        this.myWatcher = myWatcher;
        this.server = server;
    }

    /**
     * In order to implement a file watcher, we loop forever
     * ensuring requesting to take the next item from the file
     * watchers queue.
     */
    @Override
    public void run() {
        try {
            // get the first event before looping
            WatchKey key = myWatcher.take();
            while(key != null) {
                // we have a polled event, now we traverse it and
                // receive all the states from it
                for (WatchEvent event : key.pollEvents()) {
                    System.out.printf("Received %s event for file: %s\n",
                            event.kind(), event.context() );
                    System.out.printf("Received\n");
                    String line = "Received " + event.kind() + " event for file: " + event.context() + "\n";
                    server.StartCommunicationg(line + "\n");
                    System.out.printf(" Not Received\n");
                }
                key.reset();
                key = myWatcher.take();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Stopping thread");
    }
}

服务器：

package com.company;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by Ivan on 3/16/2016.
 */
public class CommunicationServer {
    private static int port = 20222;
    private static ServerSocket listenSock = null;
    private Socket sock = null;
    private static CommunicationServer instance = null;

    protected CommunicationServer() {
        System.out.println("Communication has started");
    }

    public static CommunicationServer getInstance() {
        if (instance == null) {
            instance = new CommunicationServer();
            try{
                listenSock = new ServerSocket(port);
            } catch (IOException ex){
                ex.printStackTrace();
            }
        }

        return instance;
    }

    public void StartCommunicationg(String message) {
        try {



            //while(true) {
                this.sock = listenSock.accept();

                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));

                writer.write(message + "/n");
                writer.flush();
                writer.close();
                sock.close();
            //}
        } catch (IOException ex) {
            ex.printStackTrace();
        }


    }
}

PHP

<?php

$PORT = 20222; //the port on which we are connecting to the "remote" machine
$HOST = "localhost"; //the ip of the remote machine (in this case it's the same machine)

$sock = socket_create(AF_INET, SOCK_STREAM, 0) //Creating a TCP socket
        or die("error: could not create socket\n");

$succ = socket_connect($sock, $HOST, $PORT) //Connecting to to server using that socket
        or die("error: could not connect to host\n");

//$text = "Hello, Java!"; //the text we want to send to the server

//socket_write($sock, $text . "\n", strlen($text) + 1) //Writing the text to the socket
        //or die("error: failed to write to socket\n");

$reply = socket_read($sock, 10000, PHP_NORMAL_READ) //Reading the reply from socket
        or die("error: failed to read from socket\n");

echo $reply;
?>

整个想法是我有一个文件夹让我们说D：\ Test。不确定是否有显示用户是否有更改 - 仅使用PHP创建文件夹或文件。所以我决定使用Java来寻找文件系统中的变化。当有变化时，用户应该看到让我们在浏览器中说出通知。如果PHP应用程序没有运行，Java应用程序应检查此文件夹中的更改，当PHP应用程序再次运行时，它应该会收到所有在文件夹中完成的更改..由于这两个应用程序之间的通信存在很多问题，我想知道使用数据库是否更好？但接下来的问题是，PHP将如何知道数据库已更新......在这里真的很困惑......

非常感谢任何帮助。

此致伊万

Answer 1

基本上我不同意您的CommunicationServer Java类，最好使用Java Servlet，而不是使用套接字和PHP。

如果您想使用此策略，我必须说浏览器上加载的网页不会自动刷新，需要您按刷新键或添加一段时间后可以加载的AJAX代码。例如，你可以使用像这样的代码

setInterval(function(){
  // your code
}, 10000);

有关此范围内的详细信息，我强烈建议您查看此link

Answer 2

尝试了解您的问题，我认为您可能需要额外的流程。 AJAX可以提供帮助，但它无法解决PHP需要继续旋转的问题。

您可以使用AJAX继续轮询PHP实例，但我认为它会错过在轮询时间之间发生的任何文件更改事件，因为它们似乎没有被PHP会话捕获。

一个解决方案是WebSockets，它允许您基于事件将数据传递给用户，因此，您可以为Java应用程序提供一个TCP套接字，为最终用户提供一个WebSocket，它将通过有关文件发生变化的任何信息，但支持有限，这可能很困难。

或者，您可以在后台运行的PHP服务器上有一个进程，将此信息提交给各种类型的数据库（因为它在同一服务器上运行，Java applet可能会这样做，具体取决于您的方案）然后只是为条目添加时间戳，并让AJAX轮询PHP会话。这样，无论轮询时间如何，都不会丢失或丢弃任何内容，如果条目不再相关，您可以在转发条目后将其删除。

无论哪种方式，使用Web浏览器解决这个问题都很棘手，因为您正试图通知客户端有新信息。如果你感到懒惰，你可以让PHP从不关闭会话，并继续将数据回显给浏览器。

Java和PHP套接字通信和AJAX

2 个答案: