Java/Language Basics/Log
Содержание
- 1 A file handler that appends.
- 2 Alternate XML by using FileHandler
- 3 An example of a program providing the functionality of logging
- 4 A simple wrapper around JDK logging facilities
- 5 Basic Logging Example
- 6 Comparing Log Levels: To compare the severity of two logging levels, use Level.intValue().
- 7 Config Demo
- 8 config.properties
- 9 Configure Logging
- 10 Configuring Logger Default Values with a Properties File
- 11 Create a memory handler with a memory of 100 records and dumps the records into the file my.log
- 12 Create log with package name
- 13 Creating a Custom Formatter for a Logger Handler
- 14 Creating a Custom Log Level
- 15 Custom filter
- 16 #define the properties for the SocketHandler
- 17 Define your own Custom Formatter
- 18 Determining If a Message Will Be Logged
- 19 Determining When the Logging Configuration Properties are Reread
- 20 Email Logger
- 21 File Logger
- 22 Flush File Handler and Logger
- 23 Handling Errors While Parsing an XML File
- 24 How to write custom Log handler
- 25 Java log: alternate XML log
- 26 Java Log:Basic Logging
- 27 Java log: Basic logging 2
- 28 Java log: Custom XML Formatter
- 29 Java log: File Handler Demo
- 30 Java log: Hierarchy logging
- 31 Java log: Localize Logging
- 32 Java log: Log and Window(JFrame, frame)
- 33 Java log: log filter
- 34 Java log: Logging Server
- 35 Java log: Memory Handler Demo
- 36 Java log: Remote Config Reader
- 37 Java log: Socket Handler Demo
- 38 Java log: Stream Handler Demo
- 39 Java log: various log methods
- 40 Java log: XML log
- 41 Limiting the Size of a Log by Using a Rotating Sequence of Files
- 42 Limiting the Size of a Log File
- 43 Localized Logging
- 44 Log Client Filter
- 45 Logger Demo
- 46 Logger with XMLFormatter and FileHandler
- 47 Logging a Method Call
- 48 Logging an Exception
- 49 Logging Example 1
- 50 Logging Level Manipulation
- 51 Logging Levels
- 52 Log HTML Table Formatter
- 53 Log level
- 54 Log multiple Handlers
- 55 Log multiple Handlers 2
- 56 Log To File with FileHandler
- 57 Log to file with FileHandler and SimpleFomatter
- 58 Memory Handler Demo
- 59 Minimizing the Impact of Logging Code
- 60 Override LogRecord toString()
- 61 Preventing a Logger from Forwarding Log Records to Its Parent
- 62 Remote ConfigReader with URLConnection
- 63 Return a message for logging.
- 64 Setting a Filter on a Logger Handler
- 65 Setting the Formatter of a Logger Handler
- 66 Simple Log Formatter Example
- 67 Socket Handler Demo
- 68 Stream Handler
- 69 The Patterns in FileHandler
- 70 The Quintessential Logging Program
- 71 Use Logger with simple formatter and FileHandler
- 72 Using Regular Expressions based on StreamHandler
- 73 Window Handler: display log message in a window(JFrame)
- 74 Writing Log Records Only After a Condition Occurs
- 75 Writing Log Records to a Log File
- 76 Writing Log Records to Standard Error
- 77 XMLFormatter based Logging
A file handler that appends.
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { boolean append = true; FileHandler handler = new FileHandler("my.log", append); Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(handler); }
}
</source>
Alternate XML by using FileHandler
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { FileHandler handler = new FileHandler("alterxml.xml"); Logger logger = Logger.getLogger("your.logging"); logger.addHandler(handler); logger.log(Level.INFO, "alternative xml"); }
}
</source>
An example of a program providing the functionality of logging
<source lang="java">
import java.util.logging.Logger; public class Main{
public static void main(String[] args) { Logger log = Logger.getLogger("com.mycompany.BasicLogging"); log.severe("severe message"); log.warning("warning message"); log.info("info message"); log.config("config message"); log.fine("fine level one message"); log.finer("fine level two message"); log.finest("fine level three message"); }
}
</source>
A simple wrapper around JDK logging facilities
<source lang="java">
/***
* This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Project: www.simpledbm.org * Author : Dibyendu Majumdar * Email : dibyendu@mazumdar.demon.co.uk */
import java.io.FileInputStream; import java.io.IOException; import java.util.logging.Level; import java.util.logging.LogManager; /**
* A simple wrapper around JDK logging facilities. The aim is to allow * easy switch to another logging system, such as Log4J. * * @author Dibyendu Majumdar */
public final class Logger {
/** * Instance of the real logger object. */ private final java.util.logging.Logger realLogger; /** * Obtain a new or existing Logger instance. * @param name Name of the logger, package names are recommended */ public static Logger getLogger(String name) { return new Logger(name); } public static void configure(String filename) { FileInputStream is = null; try { is = new FileInputStream(filename); LogManager.getLogManager().readConfiguration(is); } catch (Exception e) { System.err.println("SIMPLEDBM-ERROR: Failed to initialize logging system due to following error: " + e.getMessage()); e.printStackTrace(); } finally { try { is.close(); } catch (IOException e) {} } } public Logger(String name) { realLogger = java.util.logging.Logger.getLogger(name); } public void info(String sourceClass, String sourceMethod, String message) { realLogger.logp(Level.INFO, sourceClass, sourceMethod, message); } public void info(String sourceClass, String sourceMethod, String message, Throwable thrown) { realLogger.logp(Level.INFO, sourceClass, sourceMethod, message, thrown); } public void debug(String sourceClass, String sourceMethod, String message) { realLogger.logp(Level.FINE, sourceClass, sourceMethod, message); } public void debug(String sourceClass, String sourceMethod, String message, Throwable thrown) { realLogger.logp(Level.FINE, sourceClass, sourceMethod, message, thrown); } public void trace(String sourceClass, String sourceMethod, String message) { realLogger.logp(Level.FINER, sourceClass, sourceMethod, message); } public void trace(String sourceClass, String sourceMethod, String message, Throwable thrown) { realLogger.logp(Level.FINER, sourceClass, sourceMethod, message, thrown); } public void warn(String sourceClass, String sourceMethod, String message) { realLogger.logp(Level.WARNING, sourceClass, sourceMethod, message); } public void warn(String sourceClass, String sourceMethod, String message, Throwable thrown) { realLogger.logp(Level.WARNING, sourceClass, sourceMethod, message, thrown); } public void error(String sourceClass, String sourceMethod, String message) { realLogger.logp(Level.SEVERE, sourceClass, sourceMethod, message); } public void error(String sourceClass, String sourceMethod, String message, Throwable thrown) { realLogger.logp(Level.SEVERE, sourceClass, sourceMethod, message, thrown); } public boolean isTraceEnabled() { return realLogger.isLoggable(Level.FINER); } public boolean isDebugEnabled() { return realLogger.isLoggable(Level.FINE); } public void enableDebug() { realLogger.setLevel(Level.FINE); } public void disableDebug() { realLogger.setLevel(Level.INFO); }
}
</source>
Basic Logging Example
<source lang="java">
import java.util.logging.*; public class BasicLoggingExample {
public static void main(String args[]) { Logger logger = Logger.getLogger("BasicLoggingExample"); logger.log(Level.INFO, "Test of logging system"); }
}
</source>
Comparing Log Levels: To compare the severity of two logging levels, use Level.intValue().
<source lang="java">
import java.util.logging.Level; public class Main {
public static void main(String[] argv) throws Exception { Level level1 = Level.INFO; Level level2 = Level.CONFIG; if (level1.intValue() > level2.intValue()) { System.out.println("level1 is more severe"); } else if (level1.intValue() < level2.intValue()) { System.out.println("level2 is more severe"); } else { System.out.println("level1 == level2"); } }
}
</source>
Config Demo
<source lang="java">
import java.util.logging.Logger; import java.util.logging.SocketHandler; public class Main {
public static void main(String args[])throws Exception { Logger logger = Logger.getLogger("logging"); logger.addHandler(new SocketHandler()); logger.warning("SocketHandler is working..."); }
}
</source>
config.properties
<source lang="java">
- define the logger level
your.logging.level=INFO
</source>
Configure Logging
<source lang="java">
// : c15:ConfigureLogging.java //{JVMArgs: -Djava.util.logging.config.file=log.prop} //{Clean: java0.log,java0.log.lck} //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Logger; public class ConfigureLogging {
static Logger lgr = Logger.getLogger("com"), lgr2 = Logger .getLogger("com.bruceeckel"), util = Logger .getLogger("com.bruceeckel.util"), test = Logger .getLogger("com.bruceeckel.test"), rand = Logger .getLogger("random"); public ConfigureLogging() { /* * Set Additional formatters, Filters and Handlers for the loggers here. * You cannot specify the Handlers for loggers except the root logger * from the configuration file. */ } public static void main(String[] args) { sendLogMessages(lgr); sendLogMessages(lgr2); sendLogMessages(util); sendLogMessages(test); sendLogMessages(rand); } private static void sendLogMessages(Logger logger) { System.out.println(" Logger Name : " + logger.getName() + " Level: " + logger.getLevel()); logger.finest("Finest"); logger.finer("Finer"); logger.fine("Fine"); logger.config("Config"); logger.info("Info"); logger.warning("Warning"); logger.severe("Severe"); }
} ///:~
</source>
Configuring Logger Default Values with a Properties File
<source lang="java">
- The following creates two handlers
handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler
- Set the default logging level for the root logger
.level = ALL
- Set the default logging level for new ConsoleHandler instances
java.util.logging.ConsoleHandler.level = INFO
- Set the default logging level for new FileHandler instances
java.util.logging.FileHandler.level = ALL
- Set the default formatter for new ConsoleHandler instances
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
- Set the default logging level for the logger named com.mycompany
com.mycompany.level = ALL The custom logging properties file is loaded by specifying a system property on the command line: java -Djava.util.logging.config.file=mylogging.properties <class>
</source>
Create a memory handler with a memory of 100 records and dumps the records into the file my.log
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main {
public static void main(String[] argv) throws Exception { FileHandler fhandler = new FileHandler("my.log"); int numRec = 100; MemoryHandler mhandler = new MemoryHandler(fhandler, numRec, Level.OFF) { public synchronized void publish(LogRecord record) { super.publish(record); push(); } }; Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(mhandler); }
}
</source>
Create log with package name
<source lang="java">
import org.apache.log4j.*; public class SimpleLogging {
public static void main(String[] args) { Logger logger = Logger.getLogger(SimpleLogging.class.getPackage().getName()); logger.info("Hello this is an info message"); }
}
</source>
Creating a Custom Formatter for a Logger Handler
<source lang="java">
import java.util.Date; import java.util.logging.FileHandler; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; class MyHtmlFormatter extends Formatter {
public String format(LogRecord rec) { StringBuffer buf = new StringBuffer(1000); if (rec.getLevel().intValue() >= Level.WARNING.intValue()) { buf.append(""); buf.append(rec.getLevel()); buf.append(""); } else { buf.append(rec.getLevel()); } buf.append(" "); buf.append(rec.getMillis()); buf.append(" "); buf.append(formatMessage(rec)); buf.append("\n"); return buf.toString(); } public String getHead(Handler h) {return "<HTML><HEAD>" + (new Date()) + "</HEAD><BODY>
\n"; } public String getTail(Handler h) { return "</BODY></HTML>\n";
}
} public class Main {
public static void main(String[] argv) throws Exception { Logger logger = Logger.getLogger("com.mycompany"); FileHandler fh = new FileHandler("mylog.html"); fh.setFormatter(new MyHtmlFormatter()); logger.addHandler(fh); logger.setLevel(Level.ALL); logger.severe("my severe message"); logger.info("my info message"); logger.entering("Main class", "myMethod", new Object[] { "para1", "para2" }); }
}
</source>
Creating a Custom Log Level
<source lang="java">
import java.util.logging.Level; import java.util.logging.Logger; class MyLevel extends Level {
public static final Level DISASTER = new MyLevel("DISASTER", Level.SEVERE.intValue() + 1); public MyLevel(String name, int value) { super(name, value); }
} public class Main {
public static void main(String[] argv) throws Exception { Logger logger = Logger.getLogger("com.mycompany"); logger.log(MyLevel.DISASTER, "my disaster message"); Level disaster = Level.parse("DISASTER"); logger.log(disaster, "my disaster message"); }
}
</source>
Custom filter
<source lang="java">
import java.util.logging.Filter; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; class Person {
private String name = null; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; }
} class AgeFilter implements Filter {
public boolean isLoggable(LogRecord record) { boolean result = false; Object[] objs = record.getParameters(); Person person = (Person) objs[0]; if (person != null) { int age = person.getAge(); if (age > 30) result = true; else result = false; } return result; }
} public class Main {
public static void main(String args[]) { Logger logger = Logger.getLogger("your.logging"); AgeFilter filter = new AgeFilter(); logger.setFilter(filter); Person person = new Person("YourName", 32); logger.log(Level.INFO, "Person has age " + person.getAge(), person); }
}
</source>
#define the properties for the SocketHandler
<source lang="java">
java.util.logging.SocketHandler.level=INFO java.util.logging.SocketHandler.host=localhost java.util.logging.SocketHandler.port=2020
</source>
Define your own Custom Formatter
<source lang="java">
import java.util.logging.Formatter; import java.util.logging.LogRecord; public class CustomFormatter extends Formatter {
public synchronized String format(LogRecord record) { String methodName = record.getSourceMethodName(); String message = record.getMessage(); StringBuffer buffer = new StringBuffer(50); buffer.append(methodName); buffer.append("="); buffer.append(message); return buffer.toString(); }
}
</source>
Determining If a Message Will Be Logged
<source lang="java">
import java.util.logging.Level; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { Logger logger = Logger.getLogger("com.mycompany.MyClass"); // Check if the message will be logged if (logger.isLoggable(Level.FINEST)) { logger.finest("my finest message"); } }
}
</source>
Determining When the Logging Configuration Properties are Reread
<source lang="java">
import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.util.logging.LogManager; public class Main {
public static void main(String[] argv) throws Exception { // Register for the event LogManager.getLogManager().addPropertyChangeListener(new PropertyChangeListener() { // This method is called when configuration file is reread public void propertyChange(PropertyChangeEvent evt) { String propName = evt.getPropertyName(); Object oldValue = evt.getOldValue(); Object newValue = evt.getOldValue(); // All values are null } }); }
}
</source>
Email Logger
<source lang="java">
//: c15:EmailLogger.java // {RunByHand} Must be connected to the Internet // {Depends: mail.jar,activation.jar} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.*; import java.io.*; import java.util.Properties; import javax.mail.*; import javax.mail.internet.*; public class EmailLogger {
private static Logger logger = Logger.getLogger("EmailLogger"); public static void main(String[] args) throws Exception { logger.setUseParentHandlers(false); Handler conHdlr = new ConsoleHandler(); conHdlr.setFormatter(new Formatter() { public String format(LogRecord record) { return record.getLevel() + " : " + record.getSourceClassName() + ":" + record.getSourceMethodName() + ":" + record.getMessage() + "\n"; } }); logger.addHandler(conHdlr); logger.addHandler( new FileHandler("EmailLoggerOutput.xml")); logger.addHandler(new MailingHandler()); logger.log(Level.INFO, "Testing Multiple Handlers", "SendMailTrue"); }
} // A handler that sends mail messages class MailingHandler extends Handler {
public void publish(LogRecord record) { Object[] params = record.getParameters(); if(params == null) return; // Send mail only if the parameter is true if(params[0].equals("SendMailTrue")) { new MailInfo("bruce@theunixman.ru", new String[] { "bruce@theunixman.ru" }, "smtp.theunixman.ru", "Test Subject", "Test Content").sendMail(); } } public void close() {} public void flush() {}
} class MailInfo {
private String fromAddr; private String[] toAddr; private String serverAddr; private String subject; private String message; public MailInfo(String from, String[] to, String server, String subject, String message) { fromAddr = from; toAddr = to; serverAddr = server; this.subject = subject; this.message = message; } public void sendMail() { try { Properties prop = new Properties(); prop.put("mail.smtp.host", serverAddr); Session session = Session.getDefaultInstance(prop, null); session.setDebug(true); // Create a message Message mimeMsg = new MimeMessage(session); // Set the from and to address Address addressFrom = new InternetAddress(fromAddr); mimeMsg.setFrom(addressFrom); Address[] to = new InternetAddress[toAddr.length]; for(int i = 0; i < toAddr.length; i++) to[i] = new InternetAddress(toAddr[i]); mimeMsg.setRecipients(Message.RecipientType.TO,to); mimeMsg.setSubject(subject); mimeMsg.setText(message); Transport.send(mimeMsg); } catch (Exception e) { throw new RuntimeException(e); } }
} ///:~
</source>
File Logger
<source lang="java">
/* Software Architecture Design Patterns in Java by Partha Kuchana Auerbach Publications
- /
import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileLogger {
public synchronized void log(String msg) { DataOutputStream dos = null; try { dos = new DataOutputStream(new FileOutputStream("log.txt", true)); dos.writeBytes(msg); dos.close(); } catch (FileNotFoundException ex) { // } catch (IOException ex) { // } }
}
</source>
Flush File Handler and Logger
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class Main {
public static void main(String[] args) throws Exception { FileHandler handler = null; Logger logger = Logger.getLogger("logging"); handler = new FileHandler("pattern", 1000, 2); logger.addHandler(handler); LogRecord record = new LogRecord(Level.INFO, "Logged in a file..."); logger.log(record); handler.flush(); handler.close(); }
}
</source>
Handling Errors While Parsing an XML File
<source lang="java">
import java.io.File; import java.util.logging.Level; import java.util.logging.Logger; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.xml.sax.ErrorHandler; import org.xml.sax.SAXParseException; public class Main {
public static void main(String[] argv) throws Exception { DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); builder.setErrorHandler(new MyErrorHandler()); Document doc = builder.parse(new File("infilename.xml")); }
} class MyErrorHandler implements ErrorHandler {
public void error(SAXParseException e) { log(Level.SEVERE, "Error", e); } public void fatalError(SAXParseException e) { log(Level.SEVERE, "Fatal Error", e); } public void warning(SAXParseException e) { log(Level.WARNING, "Warning", e); } private Logger logger = Logger.getLogger("com.mycompany"); private void log(Level level, String message, SAXParseException e) { int line = e.getLineNumber(); int col = e.getColumnNumber(); String publicId = e.getPublicId(); String systemId = e.getSystemId(); message = message + ": " + e.getMessage() + ": line=" + line + ", col=" + col + ", PUBLIC=" + publicId + ", SYSTEM=" + systemId; logger.log(level, message); }
}
</source>
How to write custom Log handler
<source lang="java">
// : c15:CustomHandler.java //How to write custom handler //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.ArrayList; import java.util.List; import java.util.logging.Handler; import java.util.logging.LogRecord; import java.util.logging.Logger; public class CustomHandler {
private static Logger logger = Logger.getLogger("CustomHandler"); private static List strHolder = new ArrayList(); public static void main(String[] args) { logger.addHandler(new Handler() { public void publish(LogRecord logRecord) { strHolder.add(logRecord.getLevel() + ":"); strHolder.add(logRecord.getSourceClassName() + ":"); strHolder.add(logRecord.getSourceMethodName() + ":"); strHolder.add("<" + logRecord.getMessage() + ">"); strHolder.add("\n"); } public void flush() { } public void close() { } }); logger.warning("Logging Warning"); logger.info("Logging Info"); System.out.print(strHolder); }
} ///:~
</source>
Java log: alternate XML log
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; public class AlternateXML {
public static void main(String args[]) { try { FileHandler handler = new FileHandler("alterxml.xml"); Logger logger = Logger.getLogger("jexp.logging"); logger.addHandler(handler); logger.log(Level.INFO, "alternative xml"); } catch (Exception e) { e.printStackTrace(); } }
}
</source>
Java Log:Basic Logging
<source lang="java">
import java.util.logging.*; import java.io.*; public class BasicLogging {
private static Logger logger = Logger.getLogger("MyLogger"); private ConsoleHandler console = null; private FileHandler file = null; public BasicLogging() { console = new ConsoleHandler(); try{ file = new FileHandler("basicLogging.out"); }catch(IOException ioe){ logger.warning("Could not create a file..."); } logger.addHandler(console); logger.addHandler(file); } public void logMessage() { logger.info("I am logging test message.."); } public static void main(String args[]) { BasicLogging demo = new BasicLogging(); demo.logMessage(); }
}
</source>
Java log: Basic logging 2
<source lang="java">
import java.util.logging.Logger; public class BasicLogging1 {
public static void main(String args[]) { Logger logger = Logger.getLogger("current.package"); logger.info("Simple formatted message.."); }
}
</source>
Java log: Custom XML Formatter
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; import java.io.*; class CustomFormatter extends Formatter {
public CustomFormatter(){} /** This method formats the given log record, in a java properties file style */ public synchronized String format(LogRecord record) { String methodName = record.getSourceMethodName(); String message = record.getMessage(); StringBuffer buffer = new StringBuffer(50); buffer.append(methodName); buffer.append("="); buffer.append(message); return buffer.toString(); }
} public class CustomFormatterTest{
private static Logger logger = Logger.getLogger("sam.logging"); private String fileName = null; public CustomFormatterTest(String fileName) { this.fileName = fileName; try { FileHandler fh = new FileHandler(fileName); CustomFormatter formatter = new CustomFormatter(); fh.setFormatter(formatter); logger.addHandler(fh); }catch(IOException ioe) { ioe.printStackTrace(); } } /** * This method performs the logging activity */ public void logMessage() { logger.info("log this message"); } public static void main(String args[]) { CustomFormatterTest test = new CustomFormatterTest("name"); test.logMessage(); }
}
</source>
Java log: File Handler Demo
<source lang="java">
import java.io.IOException; import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class FileHandlerDemo {
private FileHandler handler = null; private static Logger logger = Logger.getLogger("sam.logging"); public FileHandlerDemo(String pattern) { try { handler = new FileHandler(pattern, 1000, 2); logger.addHandler(handler); } catch (IOException ioe) { ioe.printStackTrace(); } } public void logMessage() { LogRecord record = new LogRecord(Level.INFO, "Logged in a file..22."); logger.log(record); handler.flush(); handler.close(); } public static void main(String[] args) { FileHandlerDemo demo = new FileHandlerDemo("%h/log%g.out"); demo.logMessage(); }
}
</source>
Java log: Hierarchy logging
<source lang="java">
import java.util.logging.*; class ParentLogger{
private Logger logger = Logger.getLogger("sam.logging"); private Level level = null; public ParentLogger(){ level = Level.SEVERE; logger.setLevel(level); } public void aMethod() { logger.log(level, "Severe message from Parent Logger"); }
} class ChildLogger{
private Logger logger = Logger.getLogger("sam.logging.child"); private Level level = null; public ChildLogger() { //level = Level.INFO; //setting the level of this child logger, if not specified, it // will use the level of the parent logger logger.setLevel(level); } public void aMethod() { logger.log(Level.INFO, "Info message from Child Logger"); logger.log(Level.SEVERE, "Severe message from Child Logger"); }
}
public class LoggingMonitor {
public static void main(String[] args){ ParentLogger pLogger = new ParentLogger(); ChildLogger cLogger = new ChildLogger(); cLogger.aMethod(); }
}
</source>
Java log: Localize Logging
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; import java.io.*; import java.util.ResourceBundle; public class LocalizeLogging {
private static Logger logger = Logger.getLogger("sam.logging"); private String rbName = null; public LocalizeLogging(String rbName) { this.rbName = rbName; } public void logMessage() { logger.logrb(Level.INFO, "LocalizeLogging", "logMessage", rbName,"success"); } public static void main(String args[]) { //collect the name of the resource bundle String rbName = "name"; LocalizeLogging lLogging = new LocalizeLogging(rbName); lLogging.logMessage(); }
}
</source>
Java log: Log and Window(JFrame, frame)
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; import javax.swing.JFrame; import javax.swing.JTextArea; import javax.swing.JScrollPane; class LogWindow extends JFrame {
private int width; private int height; private JTextArea textArea = null; private JScrollPane pane = null; public LogWindow(String title, int width, int height) { super(title); setSize(width, height); textArea = new JTextArea(); pane = new JScrollPane(textArea); getContentPane().add(pane); setVisible(true); } /** * This method appends the data to the text area. * * @param data * the Logging information data */ public void showInfo(String data) { textArea.append(data); this.getContentPane().validate(); }
} class WindowHandler extends Handler {
//the window to which the logging is done private LogWindow window = null; private Formatter formatter = null; private Level level = null; //the singleton instance private static WindowHandler handler = null; /** * private constructor, preventing initialization */ private WindowHandler() { configure(); if (window == null) window = new LogWindow("Logging window", 500, 200); } /** * The getInstance method returns the singleton instance of the * WindowHandler object It is synchronized to prevent two threads trying to * create an instance simultaneously. @ return WindowHandler object */ public static synchronized WindowHandler getInstance() { if (handler == null) { handler = new WindowHandler(); } return handler; } /** * This method loads the configuration properties from the JDK level * configuration file with the help of the LogManager class. It then sets * its level, filter and formatter properties. */ private void configure() { LogManager manager = LogManager.getLogManager(); String className = this.getClass().getName(); String level = manager.getProperty(className + ".level"); String filter = manager.getProperty(className + ".filter"); String formatter = manager.getProperty(className + ".formatter"); //accessing super class methods to set the parameters setLevel(level != null ? Level.parse(level) : Level.INFO); setFilter(makeFilter(filter)); setFormatter(makeFormatter(formatter)); } /** * private method constructing a Filter object with the filter name. * * @param filterName * the name of the filter * @return the Filter object */ private Filter makeFilter(String filterName) { Class c = null; Filter f = null; try { c = Class.forName(filterName); f = (Filter) c.newInstance(); } catch (Exception e) { System.out.println("There was a problem to load the filter class: " + filterName); } return f; } /** * private method creating a Formatter object with the formatter name. If no * name is specified, it returns a SimpleFormatter object * * @param formatterName * the name of the formatter * @return Formatter object */ private Formatter makeFormatter(String formatterName) { Class c = null; Formatter f = null; try { c = Class.forName(formatterName); f = (Formatter) c.newInstance(); } catch (Exception e) { f = new SimpleFormatter(); } return f; } /** * This is the overridden publish method of the abstract super class * Handler. This method writes the logging information to the associated * Java window. This method is synchronized to make it thread-safe. In case * there is a problem, it reports the problem with the ErrorManager, only * once and silently ignores the others. * * @record the LogRecord object * */ public synchronized void publish(LogRecord record) { String message = null; //check if the record is loggable if (!isLoggable(record)) return; try { message = getFormatter().format(record); } catch (Exception e) { reportError(null, e, ErrorManager.FORMAT_FAILURE); } try { window.showInfo(message); } catch (Exception ex) { reportError(null, ex, ErrorManager.WRITE_FAILURE); } } public void close() { } public void flush() { }
} public class CustomHandlerDemo {
private WindowHandler handler = null; private Logger logger = null; public CustomHandlerDemo() { handler = WindowHandler.getInstance(); //obtaining a logger instance and setting the handler logger = Logger.getLogger("sam.logging.handler"); logger.addHandler(handler); } /** * This method publishes the log message */ public void logMessage() { logger.info("Hello from WindowHandler..."); } public static void main(String args[]) { //logging with the help of a logger CustomHandlerDemo demo = new CustomHandlerDemo(); demo.logMessage(); //using the handler.publish() to log WindowHandler h = WindowHandler.getInstance(); LogRecord r = new LogRecord(Level.WARNING, "The Handler publish method..."); h.publish(r); }
}
</source>
Java log: log filter
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; public class FilterDemo {
private Logger logger = null; private AgeFilter filter = null; public FilterDemo() { //obtaining a logger object logger = Logger.getLogger("sam.logging"); //creating a AgeFilter object filter = new AgeFilter(); //attaching the filter to the logger logger.setFilter(filter); } /** * This method logs the message */ public void logMessage(Person person) { //logging the message with Person object as parameter logger.log(Level.INFO, "Person has age "+person.getAge(), person); } public static void main(String args[]) { FilterDemo demo = new FilterDemo(); //creating Person objects Person person1 = new Person("Paul", 32); Person person2 = new Person("sam", 29); //logging with each Person object demo.logMessage(person1); demo.logMessage(person2); }
} class Person{
private String name = null; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; }
} class AgeFilter implements Filter {
public AgeFilter() { } /** * This is the overridden method from the Filter interface. * It checks the Person object associated with the LogRecord * checks the age>30, and returns true *@param record the LogRecord object *@return boolean true/false */ public boolean isLoggable(LogRecord record) { boolean result = false; //obtaining the Person object from the record Object[] objs = record.getParameters(); Person person = (Person)objs[0]; //check if person is not null if(person !=null) { //obtain the age int age = person.getAge(); if(age>30) result = true; else result = false; } return result; }
}
</source>
Java log: Logging Server
<source lang="java">
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; public class LoggingServer {
private ServerSocket serverSocket = null; private Socket socket = null; public LoggingServer(int port) { try { serverSocket = new ServerSocket(port); socket = serverSocket.accept(); } catch (IOException ioe) { ioe.printStackTrace(); } } public void acceptMessage() { try { InputStream inStream = socket.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(inStream)); String str = null; while ((str = reader.readLine()) != null) { System.out.println(str); } } catch (IOException ioe) { ioe.printStackTrace(); } } public static void main(String args[]) { LoggingServer server = new LoggingServer(2020); server.acceptMessage(); }
}
</source>
Java log: Memory Handler Demo
<source lang="java">
import java.util.logging.ConsoleHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class MemoryHandlerDemo {
private ConsoleHandler handler = null; private MemoryHandler mHandler = null; private static Logger logger = Logger.getLogger("sam.logging"); public MemoryHandlerDemo(int size, Level pushLevel) { handler = new ConsoleHandler(); mHandler = new MemoryHandler(handler, size, pushLevel); logger.addHandler(mHandler); logger.setUseParentHandlers(false); } public void logMessage() { LogRecord record1 = new LogRecord(Level.SEVERE, "This is SEVERE level message"); LogRecord record2 = new LogRecord(Level.WARNING, "This is WARNING level message"); logger.log(record1); logger.log(record2); } public static void main(String args[]) { MemoryHandlerDemo demo = new MemoryHandlerDemo(2, Level.SEVERE); demo.logMessage(); }
}
</source>
Java log: Remote Config Reader
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
// /* If this property is not passed to the logging framework at startup, by default, LogManager reads a configuration file located in the "JAVA_HOME/jre/lib/ logging.properties" file. This configuration file defines the default configuration parameters for the logging framework to work. It is possible to override the default location and specify our own configuration file by passing a command line option to the Java runtime as: java -Djava.util.logging.config.file=configuration file name
RemoteConfigReader.java
- /
import java.util.logging.LogManager; import java.net.URL; import java.net.URLConnection; import java.net.MalformedURLException; import java.io.InputStream; import java.io.IOException; public class RemoteConfigReader {
private String urlString = "http://www.xyz.ru/config.properties"; private URL url = null; private URLConnection urlConn = null; private InputStream inStream = null; private LogManager manager = null; /** * The constructor obtains a connection to the URL specified in the * urlString object, obtains an InputStream on the URL and * calls the readConfiguration(InputStream) of the LogManager class * to perform the initialization */ public RemoteConfigReader(){ try{ url = new URL(urlString); urlConn = url.openConnection(); inStream = urlConn.getInputStream(); manager = LogManager.getLogManager(); manager.readConfiguration(inStream); }catch(MalformedURLException mue){ System.out.println("could not open url: "+urlString); }catch(IOException ioe){ System.out.println("IOException occured in reading: "+urlString); }catch(SecurityException se){ System.out.println("Security exception occured in class RemoteConfigLoader"); } }
}
</source>
Java log: Socket Handler Demo
<source lang="java">
import java.io.IOException; import java.util.logging.Logger; import java.util.logging.SocketHandler; public class SocketHandlerDemo {
private SocketHandler handler = null; private static Logger logger = Logger.getLogger("sam.logging"); public SocketHandlerDemo(String host, int port) { try { handler = new SocketHandler(host, port); logger.addHandler(handler); } catch (IOException ioe) { ioe.printStackTrace(); } } public void logMessage() { logger.warning("SocketHandler is working..."); } public static void main(String args[]) { SocketHandlerDemo demo = new SocketHandlerDemo("localhost", 2020); demo.logMessage(); }
}
</source>
Java log: Stream Handler Demo
<source lang="java">
import java.io.OutputStream; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import java.util.logging.StreamHandler; public class StreamHandlerDemo {
private StreamHandler handler = null; private OutputStream outStream = null; private static Logger logger = Logger.getLogger("sam.logging"); public StreamHandlerDemo() { outStream = System.out; handler = new StreamHandler(outStream, new SimpleFormatter()); logger.addHandler(handler); logger.setUseParentHandlers(false); } public void logMessage() { logger.info("StreamHandler is working!"); } public static void main(String[] args) { StreamHandlerDemo demo = new StreamHandlerDemo(); demo.logMessage(); }
}
</source>
Java log: various log methods
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; import java.io.IOException; public class LogMethods {
private static Logger logger = Logger.getLogger("sam.logging"); public LogMethods() { //first obtain the logmanager instance LogManager manager = LogManager.getLogManager(); //remove all the associated handlers with this manager manager.reset(); //create a new handler for the logger to write messages // to the console ConsoleHandler ch = new ConsoleHandler(); ch.setLevel(Level.FINEST); //setting the logger level and handler logger.setLevel(Level.FINEST); logger.addHandler(ch); } /** * This method demonstrates the basic logging methods */ public void printBasicMethods() { logger.log(Level.INFO, "THIS IS INFO LEVEL MESSAGE"); //creating a log record on our own LogRecord record = new LogRecord(Level.SEVERE, "OUR OWN LOGRECORD OBJECT"); //logging the log record object logger.log(record); } /** * This method demonstrates the precise logging methods */ public void printPreciseMethods() { logger.logp(Level.INFO, "LogMethods", "printPreciseMethods","PRECISE METHODS.."); } /** * This method demonstrates the level based logging methods */ public void printLevelMethods() { logger.fine("THIS IS A FINE LEVEL MESSAGE"); logger.finer("THIS IS A FINER LEVEL MESSAGE"); logger.finest("THIS IS A FINEST LEVEL MESSAGE"); logger.config("THIS IS CONFIG LEVEL MESSAGE"); } /** *This method demonstrates the method level logging methods */ public void printMethod() { logger.entering("LogMethods", "printMethod"); logger.exiting("LogMethods", "printMethod"); } public static void main(String[] args) { LogMethods lm = new LogMethods(); lm.printBasicMethods(); lm.printPreciseMethods(); lm.printLevelMethods(); lm.printMethod(); }
}
</source>
Java log: XML log
<source lang="java">
/* Logging In Java with the JDK 1.4 Logging API and Apache log4j by Samudra Gupta Apress Copyright 2003 ISBN:1590590996
- /
import java.util.logging.*; import java.io.*; public class XMLLogging {
private ConsoleHandler ch ; private XMLFormatter formatter ; private FileHandler handler = null; /** * constructor */ public XMLLogging() { ch = new ConsoleHandler(); formatter = new XMLFormatter(); } /** * This method demonstrates the logging using XMLFormatter * and should there be an exception, the exception * is logged into the console with ConsoleHandler and formatted * withXMLFormatter. */ public void logMessage() { //creating a LogRecord object with level and message LogRecord record = new LogRecord(Level.INFO, "XML message.."); try { //creating a StreamHandler object to file output the xml message handler = new FileHandler("newxml.xml"); handler.setFormatter(formatter); //publishing the log message to the file and flushing the buffer handler.publish(record); handler.flush(); }catch(Exception e) { //creating a log record object with the WARNING level //and exception message LogRecord rec = new LogRecord(Level.WARNING, e.toString()); //setting the formatter for the consolehandler as //XMLFormatter and publishing the message ch.setFormatter(formatter); ch.publish(rec); } } public static void main(String args[]) { XMLLogging logging = new XMLLogging(); logging.logMessage(); }
}
</source>
Limiting the Size of a Log by Using a Rotating Sequence of Files
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { // Create a file handler that uses 3 logfiles, each with a limit of 1Mbyte String pattern = "my%g.log"; int limit = 1000000; // 1 Mb int numLogFiles = 3; FileHandler fh = new FileHandler(pattern, limit, numLogFiles); // Add to logger Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(fh); }
}
</source>
Limiting the Size of a Log File
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { // Create a file handler with a limit of 1 megabytes String pattern = "my.log"; int limit = 1000000; // 1 Mb FileHandler fh = new FileHandler("my.log", limit, 1); // Add to logger Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(fh); }
}
</source>
Localized Logging
<source lang="java">
import java.util.logging.Level; import java.util.logging.Logger; public class Main {
public static void main(String args[]) { Logger logger = Logger.getLogger("your.logging"); String rbName = null; logger.logrb(Level.INFO, "LocalizeLogging", "logMessage", rbName, "success"); }
}
</source>
Log Client Filter
<source lang="java">
import java.util.logging.LogRecord; public class ClientFilter implements java.util.logging.Filter {
public boolean isLoggable(LogRecord record) { if (record.getMessage().startsWith("client")) return (true); else return (false); }
}
</source>
Logger Demo
<source lang="java">
import org.apache.log4j.*; public class LoggerDemo {
private static Logger logger = Logger.getLogger(LoggerDemo.class.getPackage().getName()); public LoggerDemo(String rbName) { logger.setAdditivity(false); logger.debug("A"); logger.setResourceBundle(java.util.ResourceBundle.getBundle(rbName)); logger.debug("B"); } public void doLogging(String name) { logger.debug("Entered the doLogging method.."); //do something logger.info("printing the message..."); logger.debug("Exiting the doLogging method..."); } public void doLocalizedLogging() { logger.l7dlog(Level.DEBUG, "Entry", null); logger.l7dlog(Level.DEBUG, "Exit", null); } public static void main(String args[]) { String name = args[0]; String rbName = args[1]; LoggerDemo demo = new LoggerDemo(rbName); demo.doLogging(name); demo.doLocalizedLogging(); }
}
</source>
Logger with XMLFormatter and FileHandler
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Handler; import java.util.logging.Logger; import java.util.logging.XMLFormatter; public class Main {
public static void main(String[] args) throws Exception { Logger logger = Logger.getLogger("my.log"); Handler handler = null; handler = new FileHandler("messages.log"); logger.addHandler(handler); handler.setFormatter(new XMLFormatter()); logger.info("Our first logging message"); logger.severe("Something terrible happened"); }
}
</source>
Logging a Method Call
<source lang="java">
import java.util.logging.Level; import java.util.logging.Logger; //package com.mycompany; class MyClass {
public boolean myMethod(int p1, Object p2) { Logger logger = Logger.getLogger("com.mycompany.MyClass"); if (logger.isLoggable(Level.FINER)) { logger.entering(this.getClass().getName(), "myMethod", new Object[] { new Integer(p1), p2 }); } System.out.println("Method body"); boolean result = true; if (logger.isLoggable(Level.FINER)) { logger.exiting(this.getClass().getName(), "myMethod", new Boolean(result)); logger.exiting(this.getClass().getName(), "myMethod"); } return result; }
}
</source>
Logging an Exception
<source lang="java">
import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; //package com.mycompany; public class Main {
public static void main(String[] argv) { Logger logger = Logger.getLogger("com.mycompany.MyClass"); try { throw new IOException(); } catch (Throwable e) { logger.log(Level.SEVERE, "Uncaught exception", e); } Exception ex = new IllegalStateException(); logger.throwing("Main class", "myMethod", ex); }
}
</source>
Logging Example 1
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.Logger; import java.util.logging.XMLFormatter; public class LoggingExample1 {
public static void main(String args[]) { try { LogManager lm = LogManager.getLogManager(); Logger logger; FileHandler fh = new FileHandler("log_test.txt"); logger = Logger.getLogger("LoggingExample1"); lm.addLogger(logger); logger.setLevel(Level.INFO); fh.setFormatter(new XMLFormatter()); logger.addHandler(fh); // root logger defaults to SimpleFormatter. We don"t want messages // logged twice. //logger.setUseParentHandlers(false); logger.log(Level.INFO, "test 1"); logger.log(Level.INFO, "test 2"); logger.log(Level.INFO, "test 3"); fh.close(); } catch (Exception e) { System.out.println("Exception thrown: " + e); e.printStackTrace(); } }
}
</source>
Logging Level Manipulation
<source lang="java">
// : c15:LoggingLevelManipulation.java //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.Logger; public class LoggingLevelManipulation {
private static Logger lgr = Logger.getLogger("com"), lgr2 = Logger .getLogger("com.bruceeckel"), util = Logger .getLogger("com.bruceeckel.util"), test = Logger .getLogger("com.bruceeckel.test"), rand = Logger .getLogger("random"); static void printLogMessages(Logger logger) { logger.finest(logger.getName() + " Finest"); logger.finer(logger.getName() + " Finer"); logger.fine(logger.getName() + " Fine"); logger.config(logger.getName() + " Config"); logger.info(logger.getName() + " Info"); logger.warning(logger.getName() + " Warning"); logger.severe(logger.getName() + " Severe"); } static void logMessages() { printLogMessages(lgr); printLogMessages(lgr2); printLogMessages(util); printLogMessages(test); printLogMessages(rand); } static void printLevels() { System.out.println(" -- printing levels -- " + lgr.getName() + " : " + lgr.getLevel() + " " + lgr2.getName() + " : " + lgr2.getLevel() + " " + util.getName() + " : " + util.getLevel() + " " + test.getName() + " : " + test.getLevel() + " " + rand.getName() + " : " + rand.getLevel()); } public static void main(String[] args) { printLevels(); lgr.setLevel(Level.SEVERE); printLevels(); System.out.println("com level: SEVERE"); logMessages(); util.setLevel(Level.FINEST); test.setLevel(Level.FINEST); rand.setLevel(Level.FINEST); printLevels(); System.out.println("individual loggers set to FINEST"); logMessages(); lgr.setLevel(Level.FINEST); printLevels(); System.out.println("com level: FINEST"); logMessages(); }
} ///:~
</source>
Logging Levels
<source lang="java">
// : c15:LoggingLevels.java //From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 //www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.Handler; import java.util.logging.LogManager; public class LoggingLevels {
private static Logger lgr = Logger.getLogger("com"), lgr2 = Logger .getLogger("com.bruceeckel"), util = Logger .getLogger("com.bruceeckel.util"), test = Logger .getLogger("com.bruceeckel.test"), rand = Logger .getLogger("random"); private static void logMessages() { lgr.info("com : info"); lgr2.info("com.bruceeckel : info"); util.info("util : info"); test.severe("test : severe"); rand.info("random : info"); } public static void main(String[] args) { lgr.setLevel(Level.SEVERE); System.out.println("com level: SEVERE"); logMessages(); util.setLevel(Level.FINEST); test.setLevel(Level.FINEST); rand.setLevel(Level.FINEST); System.out.println("individual loggers set to FINEST"); logMessages(); lgr.setLevel(Level.SEVERE); System.out.println("com level: SEVERE"); logMessages(); }
} ///:~
</source>
Log HTML Table Formatter
<source lang="java">
import java.util.logging.Handler; import java.util.logging.LogRecord; public class HTMLTableFormatter extends java.util.logging.Formatter {
public String format(LogRecord record) { return (" <tr><td>" + record.getMillis() + "</td><td>" + record.getMessage() + "</td></tr>\n"); } public String getHead(Handler h) {return ("
Time | Log Message |
---|
}
}
</source>
Log level
<source lang="java">
// : c15:SimpleFilter.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Filter; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class SimpleFilter {
private static Logger logger = Logger.getLogger("SimpleFilter"); static class Duck { }; static class Wombat { }; static void sendLogMessages() { logger.log(Level.WARNING, "A duck in the house!", new Duck()); logger.log(Level.WARNING, "A Wombat at large!", new Wombat()); } public static void main(String[] args) { sendLogMessages(); logger.setFilter(new Filter() { public boolean isLoggable(LogRecord record) { Object[] params = record.getParameters(); if (params == null) return true; // No parameters if (record.getParameters()[0] instanceof Duck) return true; // Only log Ducks return false; } }); logger.info("After setting filter.."); sendLogMessages(); }
} ///:~
</source>
Log multiple Handlers
<source lang="java">
// : c15:MultipleHandlers.java // {Clean: MultipleHandlers.xml,MultipleHandlers.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.FileHandler; import java.util.logging.Logger; public class MultipleHandlers {
private static Logger logger = Logger.getLogger("MultipleHandlers"); public static void main(String[] args) throws Exception { FileHandler logFile = new FileHandler("MultipleHandlers.xml"); logger.addHandler(logFile); logger.addHandler(new ConsoleHandler()); logger.warning("Output to multiple handlers"); }
} ///:~
</source>
Log multiple Handlers 2
<source lang="java">
// : c15:MultipleHandlers2.java // {Clean: MultipleHandlers2.xml,MultipleHandlers2.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.FileHandler; import java.util.logging.Logger; public class MultipleHandlers2 {
private static Logger logger = Logger.getLogger("MultipleHandlers2"); public static void main(String[] args) throws Exception { FileHandler logFile = new FileHandler("MultipleHandlers2.xml"); logger.addHandler(logFile); logger.addHandler(new ConsoleHandler()); logger.setUseParentHandlers(false); logger.warning("Output to multiple handlers"); }
} ///:~
</source>
Log To File with FileHandler
<source lang="java">
//: c15:LogToFile.java // {Clean: LogToFile.xml,LogToFile.xml.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.*; public class LogToFile {
private static Logger logger = Logger.getLogger("LogToFile"); public static void main(String[] args) throws Exception { logger.addHandler(new FileHandler("LogToFile.xml")); logger.info("A message logged to the file"); }
} ///:~
</source>
Log to file with FileHandler and SimpleFomatter
<source lang="java">
// : c15:LogToFile2.java // {Clean: LogToFile2.txt,LogToFile2.txt.lck} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.FileHandler; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class LogToFile2 {
private static Logger logger = Logger.getLogger("LogToFile2"); public static void main(String[] args) throws Exception { FileHandler logFile = new FileHandler("LogToFile2.txt"); logFile.setFormatter(new SimpleFormatter()); logger.addHandler(logFile); logger.info("A message logged to the file"); }
} ///:~
</source>
Memory Handler Demo
<source lang="java">
import java.util.logging.ConsoleHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main {
public static void main(String args[]) throws Exception { Logger logger = Logger.getLogger("your.logging"); ConsoleHandler handler = new ConsoleHandler(); MemoryHandler mHandler = new MemoryHandler(handler, 10, Level.ALL); logger.addHandler(mHandler); logger.setUseParentHandlers(false); LogRecord record1 = new LogRecord(Level.SEVERE, "This is SEVERE level message"); LogRecord record2 = new LogRecord(Level.WARNING, "This is WARNING level message"); logger.log(record1); logger.log(record2); }
}
</source>
Minimizing the Impact of Logging Code
<source lang="java">
import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { int count = 123; Logger logger = Logger.getLogger("com.mycompany.MyClass"); logger.finest("count: " + count); }
}
</source>
Override LogRecord toString()
<source lang="java">
// : c15:PrintableLogRecord.java // Override LogRecord toString() // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.Level; import java.util.logging.LogRecord; public class PrintableLogRecord extends LogRecord {
public PrintableLogRecord(Level level, String str) { super(level, str); } public String toString() { String result = "Level<" + getLevel() + ">\n" + "LoggerName<" + getLoggerName() + ">\n" + "Message<" + getMessage() + ">\n" + "CurrentMillis<" + getMillis() + ">\n" + "Params"; Object[] objParams = getParameters(); if (objParams == null) result += "<null>\n"; else for (int i = 0; i < objParams.length; i++) result += " Param # <" + i + " value " + objParams[i].toString() + ">\n"; result += "ResourceBundle<" + getResourceBundle() + ">\nResourceBundleName<" + getResourceBundleName() + ">\nSequenceNumber<" + getSequenceNumber() + ">\nSourceClassName<" + getSourceClassName() + ">\nSourceMethodName<" + getSourceMethodName() + ">\nThread Id<" + getThreadID() + ">\nThrown<" + getThrown() + ">"; return result; } public static void main(String[] args) { PrintableLogRecord logRecord = new PrintableLogRecord(Level.FINEST, "Simple Log Record"); System.out.println(logRecord); }
} ///:~
</source>
Preventing a Logger from Forwarding Log Records to Its Parent
<source lang="java">
import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { Logger logger = Logger.getLogger("com.mycompany"); // Stop forwarding log records to ancestor handlers logger.setUseParentHandlers(false); // Start forwarding log records to ancestor handlers logger.setUseParentHandlers(true); }
}
</source>
Remote ConfigReader with URLConnection
<source lang="java">
import java.io.InputStream; import java.net.URL; import java.net.URLConnection; import java.util.logging.LogManager; public class Main {
public static void main(String[] argv) throws Exception { URLConnection urlConn = null; InputStream inStream = null; LogManager manager = null; URL url = new URL("http://www.xyz.ru/config.properties"); urlConn = url.openConnection(); inStream = urlConn.getInputStream(); manager = LogManager.getLogManager(); manager.readConfiguration(inStream); }
}
</source>
Return a message for logging.
<source lang="java">
/**
* Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
import java.io.PrintWriter; import java.io.StringWriter; import java.net.InetAddress; import java.net.URI; import java.net.URISyntaxException; import java.net.UnknownHostException; import java.text.DateFormat; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.StringTokenizer; import java.util.Collection;
/**
* General string utils */
public class StringUtils {
/** * Return a message for logging. * @param prefix prefix keyword for the message * @param msg content of the message * @return a message for logging */ private static String toStartupShutdownString(String prefix, String [] msg) { StringBuffer b = new StringBuffer(prefix); b.append("\n/************************************************************"); for(String s : msg) b.append("\n" + prefix + s); b.append("\n************************************************************/"); return b.toString(); }
}
</source>
Setting a Filter on a Logger Handler
<source lang="java">
import java.util.logging.ConsoleHandler; import java.util.logging.Filter; import java.util.logging.LogRecord; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { ConsoleHandler handler = new ConsoleHandler(); handler.setFilter(new Filter() { public boolean isLoggable(LogRecord record) { return true; } }); // Add the handler to a logger Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(handler); }
}
</source>
Setting the Formatter of a Logger Handler
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class Main{
public static void main(String[] argv) throws Exception{ Logger logger = Logger.getLogger("com.mycompany"); FileHandler fh = new FileHandler("mylog.txt"); fh.setFormatter(new SimpleFormatter()); logger.addHandler(fh); // fh = new FileHandler("mylog.xml"); // fh.setFormatter(new XMLFormatter()); // logger.addHandler(fh); // Log a few messages logger.severe("my severe message"); logger.warning("my warning message"); logger.info("my info message"); logger.config("my config message"); logger.fine("my fine message"); logger.finer("my finer message"); logger.finest("my finest message"); }
}
</source>
Simple Log Formatter Example
<source lang="java">
// : c15:SimpleFormatterExample.java // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. import java.util.logging.ConsoleHandler; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.LogRecord; import java.util.logging.Logger; public class SimpleFormatterExample {
private static Logger logger = Logger.getLogger("SimpleFormatterExample"); private static void logMessages() { logger.info("Line One"); logger.info("Line Two"); } public static void main(String[] args) { logger.setUseParentHandlers(false); Handler conHdlr = new ConsoleHandler(); conHdlr.setFormatter(new Formatter() { public String format(LogRecord record) { return record.getLevel() + " : " + record.getSourceClassName() + " -:- " + record.getSourceMethodName() + " -:- " + record.getMessage() + "\n"; } }); logger.addHandler(conHdlr); logMessages(); }
} ///:~
</source>
Socket Handler Demo
<source lang="java">
import java.util.logging.Logger; import java.util.logging.SocketHandler; public class Main {
public static void main(String args[]) throws Exception{ SocketHandler handler = null; Logger logger = Logger.getLogger("your.logging"); handler = new SocketHandler("127.0.0.1", 8080); logger.addHandler(handler); logger.warning("SocketHandler is working..."); }
}
</source>
Stream Handler
<source lang="java">
import java.io.OutputStream; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import java.util.logging.StreamHandler; public class Main {
public static void main(String[] args) { Logger logger = Logger.getLogger("logging"); OutputStream outStream = System.out; StreamHandler handler = new StreamHandler(outStream, new SimpleFormatter()); logger.addHandler(handler); logger.setUseParentHandlers(false); logger.info("StreamHandler is working�"); }
}
</source>
The Patterns in FileHandler
<source lang="java">
Expression Meaning / The path separator of the local OS %t A directory suitable for storing temporary logging files, such as the temp directory of the OS %h A directory such as the "user.home" location, which is suitable to store user-specific data in the system %g A log generation number to rotate log files %u A number to make a log file unique to avoid any conflicts %% A literal percent sign
</source>
The Quintessential Logging Program
<source lang="java">
import java.util.logging.Logger; //package com.mycompany; public class Main {
public static void main(String[] args) { Logger logger = Logger.getLogger("com.mycompany.BasicLogging"); // Log a few message at different severity levels logger.severe("severe message"); logger.warning("warning message"); logger.info("info message"); logger.config("config message"); logger.fine("fine message"); logger.finer("finer message"); logger.finest("finest message"); }
}
</source>
Use Logger with simple formatter and FileHandler
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; public class Main {
public static void main(String[] args) throws Exception { Logger logger = Logger.getLogger("MyLog"); FileHandler fh; fh = new FileHandler("c:\\MyLogFile.log", true); logger.addHandler(fh); logger.setLevel(Level.ALL); SimpleFormatter formatter = new SimpleFormatter(); fh.setFormatter(formatter); logger.log(Level.WARNING, "My first log"); }
}
</source>
Using Regular Expressions based on StreamHandler
<source lang="java">
import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.StreamHandler; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MainClass {
public static void main(String args[]) { Logger log = Logger.getAnonymousLogger(); setLoggerhandler(log); log.finest(new Exception().toString()); } public static void setLoggerhandler(Logger logger) { Handler handler = new ExceptionHandler(); logger.addHandler(handler); logger.setLevel(Level.ALL); }
} class ExceptionHandler extends StreamHandler {
public void publish(LogRecord record) { String msg = record.getMessage(); int exceptionIndex = msg.indexOf("Exception"); if (exceptionIndex > -1) { Pattern pattern = Pattern.rupile("(.*Exception.*)"); Matcher matcher = pattern.matcher(msg); if (matcher != null && matcher.find()) { String err = "EXCEPTION FOUND " + matcher.group(1); System.out.println(err); } } }
}
</source>
Window Handler: display log message in a window(JFrame)
<source lang="java">
import java.util.logging.ErrorManager; import java.util.logging.Filter; import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.LogRecord; import java.util.logging.Logger; import java.util.logging.SimpleFormatter; import javax.swing.JFrame; import javax.swing.JScrollPane; import javax.swing.JTextArea; class LogWindow extends JFrame {
private JTextArea textArea = new JTextArea(); public LogWindow() { super(""); setSize(300, 300); add(new JScrollPane(textArea)); setVisible(true); } public void showInfo(String data) { textArea.append(data); this.validate(); }
} class WindowHandler extends Handler {
private LogWindow window = null; private Formatter formatter = null; private Level level = null; private static WindowHandler handler = null; private WindowHandler() { LogManager manager = LogManager.getLogManager(); String className = this.getClass().getName(); String level = manager.getProperty(className + ".level"); setLevel(level != null ? Level.parse(level) : Level.INFO); if (window == null) window = new LogWindow(); } public static synchronized WindowHandler getInstance() { if (handler == null) { handler = new WindowHandler(); } return handler; } public synchronized void publish(LogRecord record) { String message = null; if (!isLoggable(record)) return; message = getFormatter().format(record); window.showInfo(message); } public void close() { } public void flush() { }
} public class Main {
private WindowHandler handler = null; private Logger logger = null; public Main() { handler = WindowHandler.getInstance(); logger = Logger.getLogger("logging.handler"); logger.addHandler(handler); } public void logMessage() { logger.info("Hello from ..."); } public static void main(String args[]) { Main demo = new Main(); demo.logMessage(); WindowHandler h = WindowHandler.getInstance(); LogRecord r = new LogRecord(Level.WARNING, "The Handler publish method..."); h.publish(r); }
}
</source>
Writing Log Records Only After a Condition Occurs
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.MemoryHandler; public class Main {
public static void main(String[] argv) throws Exception { FileHandler fhandler = new FileHandler("my.log"); int numRec = 100; MemoryHandler mhandler = new MemoryHandler(fhandler, numRec, Level.SEVERE); Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(mhandler); }
}
</source>
Writing Log Records to a Log File
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { FileHandler handler = new FileHandler("my.log"); Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(handler); }
}
</source>
Writing Log Records to Standard Error
<source lang="java">
import java.util.logging.ConsoleHandler; import java.util.logging.Logger; public class Main {
public static void main(String[] argv) throws Exception { ConsoleHandler handler = new ConsoleHandler(); // Add to logger Logger logger = Logger.getLogger("com.mycompany"); logger.addHandler(handler); }
}
</source>
XMLFormatter based Logging
<source lang="java">
import java.util.logging.FileHandler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.XMLFormatter; public class Main {
public static void main(String args[]) throws Exception{ XMLFormatter formatter = new XMLFormatter(); LogRecord record = new LogRecord(Level.INFO, "XML message.."); FileHandler handler = new FileHandler("newxml.xml"); handler.setFormatter(formatter); handler.publish(record); handler.flush(); }
}
</source>