Déterminer le fichier utilisé par FileHandlerler

Le moyen le plus simple consiste à placer une sorte d'identifiant dans le nom de fichier lui-même, c'est-à-dire l'argument modèle lorsque vous créez le fichierHandler. Comme ce sont des instances de la même application, une façon de les distinguer est de leur identifiant de processus, de sorte que vous puissiez faire cette partie du motif. Une meilleure approche consiste à adopter un identifiant via la ligne de commande et à utiliser cela pour effectuer votre nom de fichier. De cette façon, vous contrôlez les fichiers créés dans un sens. Enfin, si votre demande a une connaissance de la raison pour laquelle il est différent de tous les autres, il se connecte par exemple à un serveur de base de données particulier, vous pouvez simplement utiliser ce nom du serveur de base de données dans le cadre du nom de fichier.

Edit: Il ne semble y avoir aucune API pour obtenir le nom du fichier utilisé par un fichierHandler. Je suggère de regarder dans les extensions de journalisation dans X4JULI (qui porte beaucoup de la fonctionnalité Log4J aux spécifications Java.Util.logging):

• http://www.x4juli.org/

  Vous devriez être capable de remplacer une instance de leur fichierHandler qui fournit une méthode getfile ():

  • http://www.x4juli.org/api/org /x4juli/handlers/filehandler.html

OK, je dois dire que le fichierHandler ne permettant pas de déterminer le fichier journal est sérieusement mutile.

J'ai chuté écrit une fonction appelée "Choisir ()" qui recherche / TMP pour le fichier journal disponible suivant Nom et renvoie ce fichier. Vous pouvez ensuite transmettre le nom de ce fichier en New FileHandler (). P>

/**
 * Utility: select a log file.  File is created immediately to reserve
 * its name.
 */
static public File chooseFile(final String basename) throws IOException {
    final int nameLen = basename.length();
    File tmpDir = new File(System.getProperty("java.io.tmpdir"));
    String[] logs = tmpDir.list(new FilenameFilter() {
        public boolean accept(File d, String f) { 
            return f.startsWith(basename);
        }
    });
    int count = 0;
    if (logs.length > 0) {
        for (String name : logs) {
            int n = atoi(name.substring(nameLen));
            if (n >= count) count = n + 1;
        }
    }
    String filename = String.format("%s%d.log", basename, count); 
    File logFile = new File(tmpDir, filename);
    logFile.createNewFile();
    return logFile;
}

En réalité, vous pouvez le faire beaucoup plus simple en étendant simplement le fichierHandler vous-même. Par exemple ...

myfileHandler.java: xxx

deleteme.java: xxx

Voici mon chemin plutôt hacky autour de cela. Il fonctionne pour la valeur par défaut si vous n'utilisez aucune chaîne de format et que vous devez travailler si vous utilisez les chaînes de format G et U dans le nom de fichier, mais pas les autres.

public class FriendlyFileHandler extends FileHandler {

    /***
     * In order to ensure the most recent log file is the file this one owns,
     * we flush before checking the directory for most recent file.
     * 
     * But we must keep other log handlers from flushing in between and making
     * a NEW recent file.
     */
    private static Object[] flushLock = new Object[0];

    private String pattern;

    public FriendlyFileHandler(String pattern, int maxLogLengthInBytes, int count) throws IOException,
            SecurityException {
        super(pattern, maxLogLengthInBytes, count);

        this.pattern = pattern;
    }

    /***
     * Finds the most recent log file matching the pattern.
     * This is just a guess - if you have a complicated pattern 
     * format it may not work.
     * 
     * IMPORTANT: This log file is still in use. You must 
     * removeHandler() on the logger first, .close() this handler, 
     * then add a NEW handler to your logger. THEN, you can read 
     * the file. 
     * 
     * Currently supported format strings: g, u
     * 
     * @return A File of the current log file, or null on error.
     */
    public synchronized File getCurrentLogFile() {

        synchronized(flushLock) {

            // so the file has the most recent date on it.
            flush();


            final String patternRegex =
                    // handle incremental number formats
                    pattern.replaceAll("%[gu]", "\\d*") +
                    // handle default case where %g is appended to end
                    "(\\.\\d*)?$";

            final Pattern re = Pattern.compile(patternRegex);
            final Matcher matcher = re.matcher("");

            // check all files in the directory where this log would be
            final File basedir = new File(pattern).getParentFile();
            final File[] logs = basedir.listFiles(new FileFilter() {

                @Override
                public boolean accept(final File pathname) {
                    // only get files that are part of the pattern
                    matcher.reset(pathname.getAbsolutePath());

                    return matcher.find();
                }

            });

            return findMostRecentLog(logs);
        }
    }

    private File findMostRecentLog(File[] logs) {

        if (logs.length > 0) {
            long mostRecentDate = 0;
            int mostRecentIdx = 0;

            for (int i = 0; i < logs.length; i++) {
                final long d = logs[i].lastModified();

                if (d >= mostRecentDate) {
                    mostRecentDate = d;
                    mostRecentIdx = i;
                }

            }

            return logs[mostRecentIdx];
        }
        else {
            return null;
        }

    }


    @Override
    public synchronized void flush() {

        // only let one Handler flush at a time.
        synchronized(flushLock) {
            super.flush();
        }
    }

}