ie heruntergeladene Datei durch eine andere ersetzen

[olek07]

Hallo zusammen,

ich versuche ein Programm zu schreiben, dass eine gerade heruntergeladene Datei in den vorgegebenen Ordner verschiebt und durch eine andere vorhandene Datei ersetzt. Das Programm muss auf Windows-Maschine laufen. Ist so was mit Java möglich?

Ich habe mit dem Watcher probiert, aber es funktioniert nicht wirklich.

Vielen Dank für eure Hilfe

import java.nio.file.*;

import static java.nio.file.StandardWatchEventKinds.*;

import static java.nio.file.LinkOption.*;

import java.nio.file.attribute.*;

import java.io.*;

import java.util.*;

import java.util.regex.*;

/**

 * Example to watch a directory (or tree) for changes to files.

 */


public class WatchDir {


    private final WatchService watcher;

    private final Map<WatchKey,Path> keys;

    private final boolean recursive;

    private boolean trace = false;


    @SuppressWarnings("unchecked")

    static <T> WatchEvent<T> cast(WatchEvent<?> event) {

        return (WatchEvent<T>)event;

    }


    /**

     * Register the given directory with the WatchService

     */

    private void register(Path dir) throws IOException {

        WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

        if (trace) {

            Path prev = keys.get(key);

            if (prev == null) {

                System.out.format("register: %s\n", dir);

            } else {

                if (!dir.equals(prev)) {

                    System.out.format("update: %s -> %s\n", prev, dir);

                }

            }

        }

        keys.put(key, dir);

    }


    /**

     * Register the given directory, and all its sub-directories, with the

     * WatchService.

     */

    private void registerAll(final Path start) throws IOException {

        // register directory and sub-directories

        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {

            @Override

            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)

                throws IOException

            {

                register(dir);

                return FileVisitResult.CONTINUE;

            }

        });

    }


    /**

     * Creates a WatchService and registers the given directory

     */

    WatchDir(Path dir, boolean recursive) throws IOException {

        this.watcher = FileSystems.getDefault().newWatchService();

        this.keys = new HashMap<WatchKey,Path>();

        this.recursive = recursive;


        if (recursive) {

            System.out.format("Scanning %s ...\n", dir);

            registerAll(dir);

            System.out.println("Done.");

        } else {

            register(dir);

        }


        // enable trace after initial registration

        this.trace = true;

    }


    /**

     * Process all events for keys queued to the watcher

     */

    void processEvents() {

        boolean nowCopied = false;

        for (; {


            // wait for key to be signalled

            WatchKey key;

            try {

                key = watcher.take();

            } catch (InterruptedException x) {

                return;

            }


            Path dir = keys.get(key);

            if (dir == null) {

                System.err.println("WatchKey not recognized!!");

                continue;

            }


            for (WatchEvent<?> event: key.pollEvents()) {

                WatchEvent.Kind kind = event.kind();


                // TBD - provide example of how OVERFLOW event is handled

                if (kind == OVERFLOW) {

                    continue;

                }


                // Context for directory entry event is the file name of entry

                WatchEvent<Path> ev = cast(event);

                Path name = ev.context();

                Path child = dir.resolve(name);


                // print out event

                // System.out.format("%s: %s\n", event.kind().name(), child);


                //if (kind == ENTRY_CREATE)

                if (kind != ENTRY_DELETE)

                {

                    Pattern p = Pattern.compile("2013-10-.*-evn\\.pdf$", Pattern.CASE_INSENSITIVE);

    		        Matcher m = p.matcher(child.toString());

    		        if (m.find())

    		        {

    		            System.out.println("nowCopied: " + nowCopied + "\n");

    		            if (!nowCopied)

    		            {

    		                System.out.println("matches"); 

                            File f = new File(child.toString());

                            System.out.print(f.delete());



                            Path copySourcePath = Paths.get("d:\\aaa.txt");

                            nowCopied = true;


                            try

                            {

                                Thread.sleep(8000);

                                System.out.print("Jetzt wird kopiert\n");

                                Files.copy(copySourcePath, child);

                                System.exit(0);

                            }

                            catch (IOException e)

                            {

                            }

                            catch (InterruptedException e)

                            {

                            }

                            finally

                            {


                            }


                            nowCopied = false;


                        }

    		        }

    		    }


                // if directory is created, and watching recursively, then

                // register it and its sub-directories

                if (recursive && (kind == ENTRY_CREATE)) {

                    try {

                        if (Files.isDirectory(child, NOFOLLOW_LINKS)) {

                            registerAll(child);

                        }

                    } catch (IOException x) {

                        // ignore to keep sample readbale

                    }

                }

            }


            // reset key and remove from set if directory no longer accessible

            boolean valid = key.reset();

            if (!valid) {

                keys.remove(key);


                // all directories are inaccessible

                if (keys.isEmpty()) {

                    break;

                }

            }

        }

    }


    static void usage() {

        System.err.println("usage: java WatchDir [-r] dir");

        System.exit(-1);

    }


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

        // parse arguments

        if (args.length == 0 || args.length > 2)

            usage();

        boolean recursive = false;

        int dirArg = 0;

        if (args[0].equals("-r")) {

            if (args.length < 2)

                usage();

            recursive = true;

            dirArg++;

        }


        // register directory and process its events

        Path dir = Paths.get(args[dirArg]);

        new WatchDir(dir, recursive).processEvents();

    }

}



[/code]

[hbspike]

Hallo vinsalve.

Du möchtest also ein Programm, dass einen Ordner überwacht und bei neuen Dateien, welche in diesen Ordner geschrieben werden, diese durch eine andere Datei ersetzt?

Mit dem WatchService kenne ich mich leider null aus. Ich wäre einen anderen Weg gegangen.

Ich hätte mir den Inhalt des Ordners zwischengespeichert und intervallmäßig überprüft ob sich was geändert hat, wenn ja, nimmst du den Pfad der neuen Datei/en und überschreibst den Inhalt einfach, nicht so elegant und etwas umständlich, aber ka was bei dem WatchService nicht funktioniert.

Gibt es denn ne Fehlermeldung , bzw. ", aber es funktioniert nicht wirklich" -> Was funktioniert nicht wirklich?

Wird kein Interrrupt erzeugt?

Springt dein Programm nicht an?

Wird die Datei nicht gelöscht, oder doch gelöscht aber nicht kopiert?

[Gast runtimeterror]

Schau mal, ob das hier funktioniert: Galileo Computing :: Java 7 - Mehr als eine Insel - 5 Dateien, Verzeichnisse und Dateizugriffe

Wenn ich das richtig im Sinn habe, muss das Betriebssystem, das Dateisystem und die Berechtigungen Watches zu setzen stimmen, damit das funktioniert. Ich vermute, dass das auf Netzlaufwerken sowie auf alten Dateisystemen nicht klappt. Mein MiniDLNA-Server hat mir mal das Log vollgejammert (um genau zu sein die ganze verdammte Platte!), dass er keine Watches mehr setzen darf - muss echt hart für den kleinen gewesen sein - es gibt also wohl ein Limit dafür. Kurzum, es gibt viele Hürden und ich meine, dass Java das als optionales Feature anbietet.

Würde mich brennend interessieren, ob du das umgesetzt bekommst - der WatchService steht auch noch auf meiner ToDo-Liste