Comment écrire des journaux dans un fichier texte avec Java.util.logging.Logger
J'ai une situation dans laquelle je veux écrire tous les journaux créés par moi dans un fichier texte.
Nous utilisons l'API Java.util.logging.Logger pour générer les journaux.
J'ai essayé:
private static Logger logger = Logger.getLogger(className.class.getName());
FileHandler fh;
fh = new FileHandler("C:/className.log");
logger.addHandler(fh);
Mais toujours obtenir mes journaux sur la console uniquement ....
Essayez cet échantillon. Ça marche pour moi.
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?");
}
Produit la sortie sur 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?
Modifier:
Pour supprimer le gestionnaire de console, utilisez
logger.setUseParentHandlers(false);
puisque ConsoleHandler est inscrit auprès du consignateur parent à partir duquel tous les enregistreurs sont dérivés.
Premièrement, où avez-vous défini votre enregistreur et à partir de quelle classe\méthode essayant de l'appeler? Il y a un exemple de travail, fraîchement cuit:
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
}
}
Dans votre code, vous avez oublié de définir le formateur. Si vous avez besoin d'un outil simple, vous pouvez le faire comme je l'ai mentionné ci-dessus, mais il existe une autre option, vous pouvez le formater vous-même. .setFormatter (new SimpleFormatter ()) code suivant):
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";
}
});
Ou toute autre modification que vous voulez. J'espère que ça aide.
L'emplacement du fichier journal peut être contrôlé via le fichier logging.properties. Et il peut être passé comme paramètre JVM ex: Java -Djava.util.logging.config.file=/scratch/user/config/logging.properties
Détails: https://docs.Oracle.com/cd/E23549_01/doc.1111/e14568/handler.htm
Configuration du gestionnaire de fichiers
Pour envoyer les journaux dans un fichier, ajoutez FileHandler à la propriété handlers du fichier logging.properties. Cela permettra la journalisation des fichiers globalement.
handlers= Java.util.logging.FileHandler Configurez le gestionnaire en définissant les propriétés suivantes:
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 spécifie l'emplacement et le modèle du fichier de sortie. Le paramètre par défaut est votre répertoire personnel.
Java.util.logging.FileHandler.limit indique, en octets, la quantité maximale que le consignateur écrit dans un fichier.
Java.util.logging.FileHandler.count spécifie le nombre de fichiers de sortie à parcourir.
Java.util.logging.FileHandler.formatter spécifie la classe de formateur Java.util.logging que la classe de gestionnaire de fichiers utilise pour formater les messages du journal. SimpleFormatter écrit de brefs résumés des enregistrements de journal "lisibles par l'homme".
Pour indiquer à Java d'utiliser ce fichier de configuration à la place de $ JDK_HOME/jre/lib/logging.properties:
Java -Djava.util.logging.config.file=/scratch/user/config/logging.properties
Une bonne bibliothèque disponible nommée log4j pour Java .
Cela fournira de nombreuses fonctionnalités. Passez par le lien et vous trouverez votre solution.
Peut-être c'est ce dont vous avez besoin ...
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 <[email protected]>
*/
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);
}
}
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?");
}
}
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);
Voici ma classe de journalisation basée sur la réponse acceptée :
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);
}
}
J'espère que les gens trouvent cela utile
public static void writeLog(String info) {
String filename = "activity.log";
String FILENAME = "C:\\testing\\" + filename;
BufferedWriter bw = null;
FileWriter fw = null;
try {
fw = new FileWriter(FILENAME, true);
bw = new BufferedWriter(fw);
bw.write(info);
bw.write("\n");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bw != null)
bw.close();
if (fw != null)
fw.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}