Come scrivere i registri nel file di testo quando si utilizza java.util.logging.Logger

Question

Ho una situazione in cui voglio scrivere tutti i registri da me creati per scrivere in un file di testo.

stiamo usando l'API java.util.logging.Logger per generare i registri.

ho cercato

private static Logger logger = Logger.getLogger(className.class.getName()); 
FileHandler fh; 
fh = new FileHandler("C:/className.log"); 
logger.addHandler(fh); 

Ma ancora ottenere i miei accede unica console ....

Answer 1

Prova questo campione. Per me funziona.

public static void main(String[] args) { 

    Logger logger = Logger.getLogger("MyLog"); 
    FileHandler fh; 

    try { 

     // This block configure the logger with handler and formatter 
     fh = new FileHandler("C:/temp/test/MyLogFile.log"); 
     logger.addHandler(fh); 
     SimpleFormatter formatter = new SimpleFormatter(); 
     fh.setFormatter(formatter); 

     // the following statement is used to log any messages 
     logger.info("My first log"); 

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

    logger.info("Hi How r u?"); 

} 

produce l'output a MyLogFile.log

Apr 2, 2013 9:57:08 AM testing.MyLogger main 
INFO: My first log 
Apr 2, 2013 9:57:08 AM testing.MyLogger main 
INFO: Hi How r u? 

Edit:

Per rimuovere il gestore console, utilizzare

logger.setUseParentHandlers(false); 

dal momento che il ConsoleHandler è regi posizionato con il logger principale da cui derivano tutti i logger.

Answer 2

Una buona libreria disponibile denominata log4j for Java.
Ciò fornirà numerose funzionalità. Vai attraverso il link e troverai la soluzione.

Answer 3

int SIZE = "<intialize-here>" 
int ROTATIONCOUNT = "<intialize-here>" 

Handler handler = new FileHandler("test.log", SIZE, LOG_ROTATIONCOUNT); 
logger.addHandler(handler);  // for your code.. 

// you can also set logging levels 
Logger.getLogger(this.getClass().getName()).log(Level.[...]).addHandler(handler); 

Answer 4

import java.io.IOException; 
import org.apache.log4j.Appender; 
import org.apache.log4j.FileAppender; 
import org.apache.log4j.Logger; 
import org.apache.log4j.SimpleLayout; 

/** 
* @author Kiran 
* 
*/ 
public class MyLogger { 

    public MyLogger() { 
    } 

    public static void main(String[] args) { 
     Logger logger = Logger.getLogger("MyLog"); 
     Appender fh = null; 
     try { 
      fh = new FileAppender(new SimpleLayout(), "MyLogFile.log"); 
      logger.addAppender(fh); 
      fh.setLayout(new SimpleLayout()); 
      logger.info("My first log"); 
     } catch (SecurityException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
     logger.info("Hi How r u?"); 
    } 
} 

Answer 5

Forse this is quello che ti serve ...

import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.io.IOException; 
import java.util.logging.FileHandler; 
import java.util.logging.Level; 
import java.util.logging.Logger; 
import javax.swing.JButton; 
import javax.swing.JFrame; 
import javax.swing.JOptionPane; 
import javax.swing.JPanel; 

/** 
* LogToFile class 
* This class is intended to be use with the default logging class of java 
* It save the log in an XML file and display a friendly message to the user 
* @author Ibrabel <ibrabel@gmail.com> 
*/ 
public class LogToFile { 

    protected static final Logger logger=Logger.getLogger("MYLOG"); 
    /** 
    * log Method 
    * enable to log all exceptions to a file and display user message on demand 
    * @param ex 
    * @param level 
    * @param msg 
    */ 
    public static void log(Exception ex, String level, String msg){ 

     FileHandler fh = null; 
     try { 
      fh = new FileHandler("log.xml",true); 
      logger.addHandler(fh); 
      switch (level) { 
       case "severe": 
        logger.log(Level.SEVERE, msg, ex); 
        if(!msg.equals("")) 
         JOptionPane.showMessageDialog(null,msg, 
          "Error", JOptionPane.ERROR_MESSAGE); 
        break; 
       case "warning": 
        logger.log(Level.WARNING, msg, ex); 
        if(!msg.equals("")) 
         JOptionPane.showMessageDialog(null,msg, 
          "Warning", JOptionPane.WARNING_MESSAGE); 
        break; 
       case "info": 
        logger.log(Level.INFO, msg, ex); 
        if(!msg.equals("")) 
         JOptionPane.showMessageDialog(null,msg, 
          "Info", JOptionPane.INFORMATION_MESSAGE); 
        break; 
       case "config": 
        logger.log(Level.CONFIG, msg, ex); 
        break; 
       case "fine": 
        logger.log(Level.FINE, msg, ex); 
        break; 
       case "finer": 
        logger.log(Level.FINER, msg, ex); 
        break; 
       case "finest": 
        logger.log(Level.FINEST, msg, ex); 
        break; 
       default: 
        logger.log(Level.CONFIG, msg, ex); 
        break; 
      } 
     } catch (IOException | SecurityException ex1) { 
      logger.log(Level.SEVERE, null, ex1); 
     } finally{ 
      if(fh!=null)fh.close(); 
     } 
    } 

    public static void main(String[] args) { 

     /* 
      Create simple frame for the example 
     */ 
     JFrame myFrame = new JFrame(); 
     myFrame.setTitle("LogToFileExample"); 
     myFrame.setSize(300, 100); 
     myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     myFrame.setLocationRelativeTo(null); 
     JPanel pan = new JPanel(); 
     JButton severe = new JButton("severe"); 
     pan.add(severe); 
     JButton warning = new JButton("warning"); 
     pan.add(warning); 
     JButton info = new JButton("info"); 
     pan.add(info); 

     /* 
      Create an exception on click to use the LogToFile class 
     */ 
     severe.addActionListener(new ActionListener(){ 

      @Override 
      public void actionPerformed(ActionEvent ae) { 
       int j = 20, i = 0; 
       try { 
        System.out.println(j/i); 
       } catch (ArithmeticException ex) { 
        log(ex,"severe","You can't divide anything by zero"); 
       } 

      } 

     }); 

     warning.addActionListener(new ActionListener(){ 

      @Override 
      public void actionPerformed(ActionEvent ae) { 
       int j = 20, i = 0; 
       try { 
        System.out.println(j/i); 
       } catch (ArithmeticException ex) { 
        log(ex,"warning","You can't divide anything by zero"); 
       } 

      } 

     }); 

     info.addActionListener(new ActionListener(){ 

      @Override 
      public void actionPerformed(ActionEvent ae) { 
       int j = 20, i = 0; 
       try { 
        System.out.println(j/i); 
       } catch (ArithmeticException ex) { 
        log(ex,"info","You can't divide anything by zero"); 
       } 

      } 

     }); 

     /* 
      Add the JPanel to the JFrame and set the JFrame visible 
     */ 
     myFrame.setContentPane(pan); 
     myFrame.setVisible(true); 
    } 
} 

Answer 6

In primo luogo, dove ha fatto si definisce il logger e da quello di classe \ metodo cercando di chiamarlo? C'è un esempio di lavoro, appena sfornato:

public class LoggingTester { 
    private final Logger logger = Logger.getLogger(LoggingTester.class 
      .getName()); 
    private FileHandler fh = null; 

    public LoggingTester() { 
     //just to make our log file nicer :) 
     SimpleDateFormat format = new SimpleDateFormat("M-d_HHmmss"); 
     try { 
      fh = new FileHandler("C:/temp/test/MyLogFile_" 
       + format.format(Calendar.getInstance().getTime()) + ".log"); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 

     fh.setFormatter(new SimpleFormatter()); 
     logger.addHandler(fh); 
    } 

    public void doLogging() { 
     logger.info("info msg"); 
     logger.severe("error message"); 
     logger.fine("fine message"); //won't show because to high level of logging 
    } 
} 

Nel codice si è dimenticato di definire la formattazione, se avete bisogno di semplice si può fare come ho già detto, ma c'è un'altra opzione, è possibile formattarlo da soli, c'è un esempio (è sufficiente inserire al posto di questa linea fh.setFormatter (nuova SimpleFormatter()) codice seguente):

fh.setFormatter(new Formatter() { 
      @Override 
      public String format(LogRecord record) { 
       SimpleDateFormat logTime = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss"); 
       Calendar cal = new GregorianCalendar(); 
       cal.setTimeInMillis(record.getMillis()); 
       return record.getLevel() 
         + logTime.format(cal.getTime()) 
         + " || " 
         + record.getSourceClassName().substring(
           record.getSourceClassName().lastIndexOf(".")+1, 
           record.getSourceClassName().length()) 
         + "." 
         + record.getSourceMethodName() 
         + "() : " 
         + record.getMessage() + "\n"; 
      } 
     }); 

O qualsiasi altra modifica quello che vuoi. Spero che sia d'aiuto.

Answer 7

La posizione del file di registro può essere controllata tramite il file logging.properties. E può essere passato come parametro JVM ex: java -Djava.util.logging.config.file=/scratch/user/config/logging.properties

Dettagli: https://docs.oracle.com/cd/E23549_01/doc.1111/e14568/handler.htm

Configurazione del gestore di file

Per inviare i log in un file, aggiungere FileHandler alla proprietà gestori nei logging.properties file. Ciò consentirà la registrazione di file a livello globale.

handlers= java.util.logging.FileHandler Configurare il gestore impostando le seguenti proprietà:

java.util.logging.FileHandler.pattern=<home directory>/logs/oaam.log 
java.util.logging.FileHandler.limit=50000 
java.util.logging.FileHandler.count=1 
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter 

java.util.logging.FileHandler.pattern specifica la posizione e la struttura del file di output. L'impostazione predefinita è la tua home directory.

java.util.logging.FileHandler.limit specifica, in byte, la quantità massima che il programma di registrazione scrive su qualsiasi file.

java.util.logging.FileHandler.count specifica il numero di file di output da scorrere.

java.util.logging.FileHandler.formatter specifica la classe di formattazione java.util.logging utilizzata dalla classe gestore file per formattare i messaggi di registro. SimpleFormatter scrive brevi riepiloghi "leggibili" dei record di log.

per istruire java per utilizzare questo file di configurazione, invece di $ JDK_HOME/JRE/lib/logging.properties:

java -Djava.util.logging.config.file=/scratch/user/config/logging.properties 

Answer 8

Qui è la mia classe di log based on the accepted answer:

import java.io.File; 
import java.io.IOException; 
import java.nio.file.Files; 
import java.nio.file.Paths; 
import java.text.DateFormat; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.logging.*; 

public class ErrorLogger 
{ 
    private Logger logger; 

    public ErrorLogger() 
    { 
     logger = Logger.getAnonymousLogger(); 

     configure(); 
    } 

    private void configure() 
    { 
     try 
     { 
      String logsDirectoryFolder = "logs"; 
      Files.createDirectories(Paths.get(logsDirectoryFolder)); 
      FileHandler fileHandler = new FileHandler(logsDirectoryFolder + File.separator + getCurrentTimeString() + ".log"); 
      logger.addHandler(fileHandler); 
      SimpleFormatter formatter = new SimpleFormatter(); 
      fileHandler.setFormatter(formatter); 
     } catch (IOException exception) 
     { 
      exception.printStackTrace(); 
     } 

     addCloseHandlersShutdownHook(); 
    } 

    private void addCloseHandlersShutdownHook() 
    { 
     Runtime.getRuntime().addShutdownHook(new Thread(() -> 
     { 
      // Close all handlers to get rid of empty .LCK files 
      for (Handler handler : logger.getHandlers()) 
      { 
       handler.close(); 
      } 
     })); 
    } 

    private String getCurrentTimeString() 
    { 
     DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); 
     return dateFormat.format(new Date()); 
    } 

    public void log(Exception exception) 
    { 
     logger.log(Level.SEVERE, "", exception); 
    } 
}