Hallöchen,

habe ein problem is zwar nur kosmetik(oder saubererer programmaufbau) aber kann ja sein dass da jemand ne antwort hat...

ich hab ne methode die rekursiv ordner durchsucht(mit unterverzeichnissen), allerdings soll sie nur dann eine log datei erstellen wenn sie nicht rekursiv aufgerufen wurde (also nur 1mal und nicht wenn die methode in unterverzeichnissen unterwegs ist) habe das momentan mit einem boolschen parameter gelöst den ich beim normalen aufruf auf false setze und beim rekursiven eben auf true und prüfe dann in der methode auf diesen parameter

if (!recursive) {

    ...

    //log datei erstellen

    ...

}

jetzt die frage da das ja ne sehr unschöne lösung ist vor allem wenn die methode noch jemand anders nutzen will usw...

kann man überprüfen (ausser mit der selbst erstellten variable) ob die methode rekursiv aufgerufen wurde?

schonmal vielen dank für eure antworten :butler

mfg

Hallo!

Wuerde fuer Deinen Anwendungsfall eine eigene Logger-Klasse in Frage kommen, die als Singleton implementiert ist?

Singleton (Entwurfsmuster) ? Wikipedia

naja ich glaube da wäre der aufwand größer als der nutzen aber ich werd mich mal reinlesen danke auf jeden fall.

falls noch jemand ne lösung hat...bin offen für alles (naja fast )

Was willst du denn so an Informationen loggen?

naja ich suche in der methode nach dateien also z.b. *.xml unterordner werden je nach aufruf rekursiv durchsucht

die methode schreibt in die log datei alle gefundenen dateien mit name pfad änderungsdatum usw und hängt diese log datei, sowie alle gefundenen dateienan an einen file vector an

in einer andern methode zippe ich dann alle gefundenen dateien + die log datei

dann bietet sich folgende lösung an:

searchFiles(fileList)

{

  searchFilesRecursive(fileList, logFile)

  fileList.add(logFile)

}

naja dadurch würde ich nur noch mehr unnötigen code erzeugen meiner meinung nach

naja dadurch würde ich nur noch mehr unnötigen code erzeugen meiner meinung nach

Das ist ja egal ... die 5 Zeilen .. :floet:

Aber es erhöht die Verständlichkeit/Lesbarkeit des Codes, wenn nicht soviele

bedingte Verzweigungen drinn sind

ok anscheinend hab ich deinen post nicht so ganz verstanden :floet:

hier mal meine methode:

public static ArrayList<File> search(String workpath, String filter, boolean sub, boolean recursive) throws Exception {

        // einen angegebenen Ordner nach einem Suchbegriff (mit regulären Ausdrücken) durchsuchen

        // je nach Aufruf, Unterordner durchsuchen


        String path;

        String parentPath;

        int nameOffset;

        String filename;


        // Pfad des Ordners für Log Dateien abrufen

        path = ConfigurationCommonHelper.getApplicationServerPhysicalPath();  //gibt den pfysikalischen Pfad des Programms aus

        path = path.replaceAll("webapp/", "logs/");


        // wenn der Ordner für die Log Dateien nicht vorhanden ist wird dieser erstellt

        File dest = new File(path);

        if (!dest.exists()) {

            dest.mkdir();

        }


        File dir = new File(workpath);          //"Zeiger" auf das Arbeitsverzeichnis setzen


        // Dateinamen ändern damit \ und / als - angezeigt werden, ".../Programmname/" nicht in den Dateinamen übernehmen

        // und den Filter anhängen. Wurde nach .* gesucht wird dieser Ausdruck durch # ersetzt da * in Windows als Teil eines

        // Dateinamens nicht zulässig ist

        parentPath = dir.getParent();

        nameOffset = parentPath.lastIndexOf("Programmname") + 5;

        filename = dir.toString().substring(nameOffset);

        filename = filename.replaceAll("\\\\", "-");

        filename = filename.replaceAll("/", "-");

        filename = filename + filter.replaceAll("\\.\\*", "#");

        logger.debug("FileSearch.search: filename=" + filename);


        ArrayList<File> toReturn = new ArrayList<File>();


        try {

            FileWriter writer;

            String log;

            Date d;

            String date;

            String time;


            File[] files = dir.listFiles();         //Inhalt des Verzeichnisses in ein FileArray schreiben



            for (int i = 0; i < files.length; i++) {                             //Inhalt des FileArrays durchlaufen

                if (files[i].isFile() && files[i].getName().matches(filter)) {  //wenn das File Element eine Datei ist UND der Vergleich mit dem regulären Ausdruck true ergibt

                    toReturn.add(files[i]);                              //File Element an die File ArrayList anhängen

                } else {

                    if (sub && files[i].isDirectory()) {                        // wenn Unterverzeichnisse durchsucht werden sollen und das File Element ein Verzeichnis ist

                        toReturn.addAll(search(files[i].toString(), filter, sub, true));       // Methode rekursiv aufrufen um das Unterverzeichnis zu durchsuchen

                    }

                }

            }


            // wurde die Methode nicht rekursiv aufgerufen wird die Log Datei erstellt in der benötigte

            // Informationen wie Änderungsdatum, Pfad und Größe gespeichert werden

            if (!recursive) {

                File logFile = new File(path + filename + ".txt");


                writer = new FileWriter(logFile.toString());  //LogDatei erstellen

                log = "Gesuchte Dateien: " + filter + "\r\nin Ordner: \t" + workpath + "\r\n\r\nSuchergebnisse:\r\n\r\n";

                writer.write(log);


                for (int i = 0; i < toReturn.size(); i++) {

                    d = new Date(toReturn.get(i).lastModified());

                    date = DateFormat.getDateInstance().format(d);

                    time = DateFormat.getTimeInstance().format(d);


                    log = "Name: " + toReturn.get(i).getName() + "\r\n";

                    log = log + "Pfad: " + toReturn.get(i).getAbsolutePath() + "\r\n";

                    log = log + "Änderungsdatum: " + date + " " + time + "\r\n";

                    log = log + "Größe: " + toReturn.get(i).length() + " Byte" + "\r\n\r\n";

                    writer.write(log);

                }

                log = "\r\n" + toReturn.size() + " Dateien gefunden!\r\n";

                writer.write(log);

                writer.close();

                toReturn.add(logFile);

            }


        } catch (Exception e) {

            try {

                FileWriter errorlog = new FileWriter(path + "SearchError.txt");

                errorlog.write("Fehler:\r\n" + e.toString() + "\r\naufgetreten!");

                errorlog.close();

            } catch (Exception e1) {

                throw e1;

            }



        }


        return toReturn;

    }

wie würdest du deinen Ansatz da jetzt einbauen? habe das so verstanden dass du ne zweite methode für die unterverzeichnisse schreiben willst :eek

kleiner hinweis...programmiere erst 2 monate in java...davor nur c++ und ein bisschen html und php

also verurteilt mich nicht falls ich da nen fauxpas in java drin habe

nameOffset = parentPath.lastIndexOf("Programmname") + 5;

die +5 einfach ignorieren...kommt daher dass "Programmname" 5 buchstaben hat bei mir :floet: